Convertidores de ajuste fino – convierta HTML, MHTML, EPUB y SVG en Java

Puede convertir HTML a varios formatos populares de varias maneras utilizando Aspose.HTML for Java:

• Utilizando los métodos convertHTML() de la clase Converter. Esta es la forma más común de convertir HTML a varios formatos.
• Utilizando el método renderTo(device) de la clase HTMLDocument o los métodos render() de la clase Renderer. Esta forma alternativa de representar documentos HTML puede brindarle más control sobre el proceso de representación HTML en su aplicación Java.

Dispositivo de renderizado – Rendering Device

El dispositivo de renderizado (rendering device) encapsula una superficie de dibujo 2D, cuya API se implementa mediante la interfaz IDevice. Actualmente, Aspose.HTML for Java API implementa un conjunto de dispositivos de renderizado: PdfDevice, XpsDevice, DocDevice y ImageDevice, que se utilizan para generar PDF. Formatos de archivo XPS, DOCX e imagen, respectivamente.

El siguiente ejemplo muestra cómo utilizar PdfDevice para convertir un documento HTML en un archivo PDF. El proceso ocurre con las opciones de renderizado predeterminadas:

1. Cargue un documento HTML.
2. Cree una instancia de la clase PdfDevice usando uno de los constructores PdfDevice().
3. Llame al método renderTo(device) de la clase HTMLDocument.

// Prepare HTML code
String code = "<span>Hello, World!!</span>";

// Initialize an HTML document from HTML code
HTMLDocument document = new HTMLDocument(code, ".");

// Create an instance of the PdfDevice class and specify the output file to render
PdfDevice device = new PdfDevice("output.pdf");

// Render HTML to PDF
document.renderTo(device);

Opciones de renderizado

Las opciones de renderizado le brindan control adicional sobre el dispositivo de salida. Cada dispositivo de renderizado PdfDevice, XpsDevice y ImageDevice tiene su propio conjunto único de opciones y se implementa con las clases PdfRenderingOptions, XpsRenderingOptions, DocRenderingOptions y ImageRenderingOptions, respectivamente. Por ejemplo, puede cambiar el tamaño de la página, ajustar los márgenes y el color de fondo, reducir el tamaño del archivo ajustando la calidad y resolución de la imagen, establecer una contraseña de seguridad si usa PdfDevice, etc.

A continuación se muestra una demostración de cómo utilizar PdfRenderingOptions para personalizar el tamaño de la página durante la representación de HTML a PDF:

// Prepare HTML code
String code = "<span>Hello, World!!</span>";

// Initialize a HTML document from the HTML code
HTMLDocument document = new HTMLDocument(code, ".");

// Create an instance of PdfRenderingOptions and set a custom page-size
PdfRenderingOptions options = new PdfRenderingOptions();
PageSetup pageSetup = new PageSetup();
Page anyPage = new Page();
anyPage.setSize(
        new Size(
                Length.fromInches(5),
                Length.fromInches(2)
        )
);
pageSetup.setAnyPage(anyPage);
options.setPageSetup(pageSetup);

// Create a PDF Device and specify options and output file
PdfDevice device = new PdfDevice(options, "output.pdf");

// Render HTML to PDF
document.renderTo(device);

Opciones generales – General Options

Las Opciones de renderizado le brindan control adicional sobre el dispositivo de salida. El paquete com.aspose.html.rendering consta de numerosos objetos de renderizado y clases de opciones de bajo nivel apropiadas responsables de renderizar documentos en la implementación de IDevice. Las clases RenderingOptions y CssOptions representan opciones de renderizado, o en otras palabras, opciones de renderizado generales.

Opciones generales son válidas para todos los dispositivos de renderizado y todos los procesos de renderizado, desde HTML a PDF, XPS, DOCX e imágenes. Veamos algunos de ellos:

Resolución horizontal y vertical

La configuración de resolución horizontal y vertical es esencial para lograr resultados de alta calidad al representar HTML en otros formatos, por ejemplo, HTML a PDF. Las resoluciones horizontal y vertical se miden en píxeles por pulgada (dpi, ppp), con un valor predeterminado de 300 dpi. Esta configuración garantiza detalles nítidos y una representación fluida de elementos como texto, imágenes y líneas horizontales y verticales en PDF.

El siguiente ejemplo muestra cómo controlar la resolución del archivo PDF resultante, lo que en última instancia afecta su tamaño y calidad:

// Prepare HTML code and save it to a file
String code = "< style >\n" +
        "                p\n" +
        "        {\n" +
        "            background:\n" +
        "            blue;\n" +
        "        }\n" +
        "        @media(min - resolution:300dpi)\n" +
        "        {\n" +
        "            p\n" +
        "            {\n" +
        "                /* high resolution screen color */\n" +
        "                background:\n" +
        "                green\n" +
        "            }\n" +
        "        }\n" +
        "    </style >\n" +
        "    <p > Hello World !! </p >\n";

try (java.io.FileWriter fileWriter = new java.io.FileWriter("document.html")) {
    fileWriter.write(code);
}

// Create an instance of the HTMLDocument class
HTMLDocument document = new HTMLDocument("document.html");

// Create options for low-resolution screens
PdfRenderingOptions options = new PdfRenderingOptions();
options.setHorizontalResolution(Resolution.to_Resolution(50d));
options.setVerticalResolution(Resolution.to_Resolution(50d));

// Create an instance of the PdfDevice
PdfDevice device = new PdfDevice(
        options,
        "output_resolution_50.pdf"
);

// Render HTML to PDF
document.renderTo(device);

// Create options for high-resolution screens
options = new PdfRenderingOptions();
options.setHorizontalResolution(Resolution.to_Resolution(300d));
options.setVerticalResolution(Resolution.to_Resolution(300d));

// Create an instance of PDF device
device = new PdfDevice(
        options,
        "output_resolution_300.pdf"
);

// Render HTML to PDF
document.renderTo(device);

CSS Media Type

El CSS media type es una característica importante que especifica cómo se presentará un documento en diferentes medios: en la pantalla, en papel, con un dispositivo braille, etc. Hay algunas formas de especificar el tipo de medio para una hoja de estilo, a través de hojas de estilo vinculadas o hoja de estilo en línea:

Hoja de estilo vinculada

 <link rel="stylesheet" type="text/css" media="print" href="style.javas">

Hoja de estilo en línea

<style type="text/css">
@media print {
  body{ color: #000000; }
}
</style>

Aspose.HTML for Java admite esta función, por lo que puede convertir documentos HTML tal como se ven en la pantalla o impresos aplicando los tipos de medios y hojas de estilo correspondientes. El siguiente ejemplo muestra cómo configurar el tipo de medio:

// Prepare HTML code
String code = "<span>Hello, World!!</span>";

// Initialize an HTML document from the HTML code
HTMLDocument document = new HTMLDocument(code, ".");

// Create an instance of the PdfRenderingOptions class
PdfRenderingOptions options = new PdfRenderingOptions();
// Set the 'screen' media-type
options.getCss().setMediaType(MediaType.Screen);

// Create a PDF Device and specify options and output file
PdfDevice device = new PdfDevice(options, "output.pdf");

// Render HTML to PDF
document.renderTo(device);

Tenga en cuenta que el valor predeterminado de CssOptions.MediaType es Print. Significa que el documento se convertirá aplicando hojas de estilo relacionadas con el dispositivo de impresión y se verá como en papel (puede usar la vista previa de impresión de su navegador para ver la diferencia). Si desea que el documento se vea tal como se muestra en la pantalla, debe usar MediaType.Screen.

Color de fondo – Background Color

La configuración Background Color es una característica fundamental para personalizar la apariencia del documento renderizado. Permite a los desarrolladores especificar el color que llenará el fondo de cada página en el archivo de salida. De forma predeterminada, esta propiedad está establecida en Transparente, lo que significa que el fondo no tendrá ningún relleno visible a menos que se especifique explícitamente. Personalizar el color de fondo puede mejorar la legibilidad de un documento, cumplir con los requisitos de marca o crear diseños visualmente atractivos.

// Prepare HTML code and save it to a file
String code = "<p>Hello, World!!</p>";
try (java.io.FileWriter fileWriter = new java.io.FileWriter("document.html")) {
    fileWriter.write(code);
}

// Create an instance of the HTMLDocument class
HTMLDocument document = new HTMLDocument("document.html");

// Initialize options with 'cyan' as a background-color
PdfRenderingOptions options = new PdfRenderingOptions();
options.setBackgroundColor(Color.getCyan());

// Create an instance of the PdfDevice class
PdfDevice device = new PdfDevice(options, "output.pdf");

// Render HTML to PDF
document.renderTo(device);

Configuración de página – Page Setup

La configuración de página es un conjunto de parámetros que determinan el diseño de una página impresa. Esos parámetros incluyen todo, desde el tamaño de la página, los márgenes y el cambio de tamaño automático hasta las reglas de prioridad @page. Con este conjunto de parámetros, puede configurar fácilmente un diseño individual para cada página.

En algunos casos, el contenido de la página HTML puede ser más ancho que el tamaño de página definido con las opciones. Si no desea cortar el contenido de la página, puede usar AdjustToWidestPage de la clase PageSetup. El siguiente ejemplo muestra cómo ajustar el tamaño de la página al contenido.

// Prepare HTML code
String code = "    <style>\n" +
        "        div {\n" +
        "            page - break -after:always;\n" +
        "        }\n" +
        "    </style >\n" +
        "    <div style = 'border: 1px solid red; width: 400px' > First Page</div >\n" +
        "    <div style = 'border: 1px solid red; width: 600px' > Second Page</div >\n";
// Initialize an HTML document from HTML code
HTMLDocument document = new HTMLDocument(code, ".");

// Create an instance of the PdfRenderingOptions class and set a custom page-size
PdfRenderingOptions options = new PdfRenderingOptions();
options.getPageSetup().setAnyPage(new Page(new Size(500, 200)));

// Enable auto-adjusting for the page size
options.getPageSetup().setAdjustToWidestPage(true);

// Create an instance of the PdfDevice class and specify options and output file
PdfDevice device = new PdfDevice(options, "output.pdf");

// Render HTML to PDF
document.renderTo(device);

Opciones de PDF

La clase PdfRenderingOptions brinda a los desarrolladores un amplio control sobre el proceso de renderizado al convertir HTML a PDF. Permite la personalización de todas las opciones generales y, además, ofrece opciones específicas para renderizar solo en formato PDF: DocumentInfo, Encryption, FormFieldBehaviour y JpegQuality.

El siguiente ejemplo demuestra la funcionalidad de configurar permisos para un archivo PDF.

// Prepare HTML code
String code = "<div>Hello, World!!</div>";

// Initialize an HTML document from the HTML code
HTMLDocument document = new HTMLDocument(code, ".");

// Create the instance of the PdfRenderingOptions class
PdfRenderingOptions options = new PdfRenderingOptions();

// Set file permissions
options.setEncryption(
        new PdfEncryptionInfo(
                "user_pwd",
                "owner_pwd",
                PdfPermissions.PrintDocument,
                PdfEncryptionAlgorithm.RC4_128
        )
);

// Create a PDF Device and specify options and output file
PdfDevice device = new PdfDevice(options, "output.pdf");

// Render HTML to PDF
document.renderTo(device);

Opciones de imagen

ImageRenderingOptions le permite personalizar una amplia gama de configuraciones, desde suavizado (antialiasing), resolución de imagen y formatos hasta compresión de imágenes. El siguiente ejemplo demuestra cómo cambiar la resolución y el antialiasing de la imagen resultante:

// Prepare HTML code
String code = "<div>Hello, World!!</div>";

// Initialize an instance of the HTMLDocument class based on prepared code
HTMLDocument document = new HTMLDocument(code, ".");

// Create an instance of the ImageRenderingOptions class
ImageRenderingOptions options = new ImageRenderingOptions();
options.setFormat(ImageFormat.Jpeg);

// Disable smoothing mode
options.setSmoothingMode(SmoothingMode.None);

// Set the image resolution as 75 dpi
options.setVerticalResolution(Resolution.fromDotsPerInch(75));
options.setHorizontalResolution(Resolution.fromDotsPerInch(75));

// Create an instance of the ImageDevice class
ImageDevice device = new ImageDevice(options, "output.jpg");

// Render HTML to Image
document.renderTo(device);

Renderizadores – Renderers

Mientras que el método renderTo(device) de la clase Document le brinda la posibilidad de enviar un solo documento al dispositivo de renderizado de salida, utilizando las instancias Renderer directamente puede enviar varios archivos a la vez. Aspose.HTML for Java proporciona la siguiente implementación de renderizadores: HtmlRenderer, SvgRenderer, MhtmlRenderer y EpubRenderer, que se utilizan para renderizar HTML, SVG, MHTML. y documentos EPUB, respectivamente.

El siguiente ejemplo demuestra cómo utilizar HtmlRenderer para representar varios documentos HTML:

// Prepare HTML code
String code1 = "<br><span style='color: green'>Hello, World!!</span>";
String code2 = "<br><span style='color: blue'>Hello, World!!</span>";
String code3 = "<br><span style='color: red'>Hello, World!!</span>";

// Create three HTML documents to merge later
HTMLDocument document1 = new HTMLDocument(code1, ".");
HTMLDocument document2 = new HTMLDocument(code2, ".");
HTMLDocument document3 = new HTMLDocument(code3, ".");

// Create an instance of HTML Renderer
HtmlRenderer renderer = new HtmlRenderer();

// Create an instance of the PdfDevice class
PdfDevice device = new PdfDevice("output.pdf");

// Merge all HTML documents to PDF
renderer.render(device, new HTMLDocument[]{document1, document2, document3});

Establecer tiempo de espera – Set Timeout

Una característica más importante que está disponible para los renderizadores es la configuración del tiempo de espera. Puede usarlo para especificar cuánto tiempo está listo para esperar a que se completen todos los procesos internos relacionados con el ciclo de vida de un documento, como la carga de recursos, temporizadores activos, etc. Claro, puede especificar un período de espera infinito. Sin embargo, si el documento contiene un script con un bucle sin fin, esperará indefinidamente. El siguiente ejemplo demuestra cómo utilizar el método render(device, timeout, documents) con el parámetro timeout:

// Prepare HTML code
String code = "< script >\n" +
        "        var count = 0;\n" +
        "        setInterval(function()\n" +
        "        {\n" +
        "            var element = document.createElement('div');\n" +
        "            var message = (++count) + '. ' + 'Hello World!!';\n" +
        "            var text = document.createTextNode(message);\n" +
        "            element.appendChild(text);\n" +
        "            document.body.appendChild(element);\n" +
        "        },1000);\n" +
        "</script >\n";

// Initialize an HTML document based on prepared HTML code
HTMLDocument document = new HTMLDocument(code, ".");

// Create an instance of HTML Renderer
HtmlRenderer renderer = new HtmlRenderer();

// Create an instance of the PdfDevice class
PdfDevice device = new PdfDevice("output.pdf");

// Render HTML to PDF
renderer.render(device, 5, document);

Conclusión

Aspose.HTML for Java es una biblioteca potente y flexible para representar HTML, MHTML, EPUB y SVG en varios formatos, como PDF, XPS, DOCX e imágenes. La clase Converter es rápida y fácil de usar para tareas sencillas. Sin embargo, si necesita más control sobre las opciones de renderizado, use el método renderTo(device).

Con una amplia gama de opciones de renderizado y funciones configurables, los desarrolladores tienen control total sobre la salida, incluida la resolución, la configuración de la página, los tipos de medios CSS y las configuraciones específicas del dispositivo. La flexibilidad de la API, demostrada por la capacidad de utilizar múltiples renderizadores, configurar opciones generales y específicas de formato e incluso administrar tiempos de espera, la convierte en una excelente opción para crear documentos personalizados de alta calidad.