Convertisseurs à réglage fin – Convertir HTML, MHTML, EPUB et SVG en Java

Aspose.HTML for Java vous permet de convertir HTML en divers formats populaires de plusieurs manières :

• En utilisant les méthodes convertHTML() de la classe Converter. C’est la façon la plus courante de convertir du HTML dans différents formats.
• En utilisant la méthode renderTo(device) de la classe HTMLDocument ou les méthodes render() de la classe Renderer. Cette autre façon de rendre les documents HTML peut vous permettre de mieux contrôler le processus de rendu HTML dans votre application Java.

Dispositif de rendu – Rendering Device

Le dispositif de rendu encapsule une surface de dessin 2D, dont l’API est mise en œuvre à l’aide de l’interface IDevice. Actuellement, l’API Aspose.HTML for Java met en œuvre un ensemble de périphériques de rendu – PdfDevice, XpsDevice, DocDevice et ImageDevice, qui sont utilisés pour générer les formats de fichier PDF, XPS, DOCX et Image, respectivement.

L’exemple suivant montre comment utiliser le PdfDevice pour convertir un document HTML en fichier PDF. Le processus se déroule avec les options de rendu par défaut :

1. Charger un document HTML.
2. Créez une instance de la classe PdfDevice en utilisant l’un des constructeurs PdfDevice().
3. Appeler la méthode renderTo(device) de la classe HTMLDocument.

// Render HTML to PDF using Java

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

Options de rendu

Les options de rendu vous donnent un contrôle supplémentaire sur le périphérique de sortie. Chaque périphérique de rendu PdfDevice, XpsDevice et ImageDevice possède son propre ensemble d’options et est implémenté avec les classes PdfRenderingOptions, XpsRenderingOptions, DocRenderingOptions et ImageRenderingOptions, respectivement. Par exemple, vous pouvez modifier la taille de la page, ajuster les marges et la couleur d’arrière-plan, réduire la taille du fichier en ajustant la qualité et la résolution de l’image, définir un mot de passe de sécurité si vous utilisez PdfDevice, etc.

Voici une démonstration de l’utilisation de PdfRenderingOptions pour personnaliser la taille de la page lors du rendu HTML vers PDF :

// Render HTML to PDF in Java with custom page size

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

Options générales

Les options de rendu vous donnent un contrôle supplémentaire sur le périphérique de sortie. Le paquetage com.aspose.html.rendering comprend de nombreux objets de rendu et des classes d’options de bas niveau appropriées responsables du rendu des documents dans l’implémentation IDevice. Les classes RenderingOptions et CssOptions représentent les options de rendu ou, en d’autres termes, les options de rendu générales.

les options générales sont valables pour tous les dispositifs de rendu et tous les processus de rendu, de HTML à PDF, XPS, DOCX et images. Examinons-en quelques-unes :

Résolution horizontale et verticale

Les paramètres de résolution horizontale et verticale sont essentiels pour obtenir une sortie de haute qualité lors de la conversion de HTML en d’autres formats, par exemple de HTML en PDF. Les résolutions horizontale et verticale sont mesurées (obtenues et définies) en pixels par pouce (ppp), avec une valeur par défaut de 300 ppp. Ce paramètre garantit la netteté des détails et la fluidité du rendu des éléments tels que le texte, les images et les lignes horizontales et verticales dans le PDF.

L’exemple suivant montre comment contrôler la résolution du fichier PDF résultant, ce qui influe sur sa taille et sa qualité :

// Render HTML to PDF with custom resolution using Java

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

Type de média CSS

Le type de média CSS est une caractéristique importante qui spécifie comment un document doit être présenté sur différents supports : à l’écran, sur papier, avec un appareil braille, etc. Il existe plusieurs façons de spécifier le type de média pour une feuille de style, via des feuilles de style liées ou des feuilles de style en ligne :

Feuille de style liée

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

Feuille de style en ligne

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

Aspose.HTML for Java prend en charge cette fonctionnalité, ce qui vous permet de convertir des documents HTML tels qu’ils apparaissent à l’écran ou à l’impression en appliquant les types de médias et les feuilles de style correspondants. L’exemple suivant montre comment configurer le type de média :

// Render HTML to PDF with custom MediaType settings with Java

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

Veuillez noter que la valeur par défaut de CssOptions.MediaType est Print. Cela signifie que le document sera converti en appliquant les feuilles de style relatives à l’appareil d’impression et qu’il aura l’apparence d’un document papier (vous pouvez utiliser l’aperçu avant impression de votre navigateur pour voir la différence). Si vous souhaitez que le document ait l’aspect d’un document rendu à l’écran, vous devez utiliser MediaType.Screen.

Couleur de fond

Le paramètre Couleur d’arrière-plan est une fonction essentielle pour personnaliser l’apparence du document rendu. Il permet aux développeurs de spécifier la couleur qui remplira l’arrière-plan de chaque page du fichier de sortie. Par défaut, cette propriété est définie sur Transparent, ce qui signifie que l’arrière-plan n’aura pas de remplissage visible à moins que cela ne soit explicitement spécifié. La personnalisation de la couleur d’arrière-plan peut améliorer la lisibilité d’un document, répondre à des exigences de marque ou créer des conceptions visuellement attrayantes.

// Render HTML to PDF with custom background color using Java

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

Mise en page

La mise en page est un ensemble de paramètres qui déterminent la disposition d’une page imprimée. Ces paramètres vont de la taille de la page, des marges et du redimensionnement automatique aux règles de priorité @page. Grâce à cet ensemble de paramètres, vous pouvez facilement définir une mise en page individuelle pour chaque page.

Dans certains cas, le contenu de la page HTML peut être plus large que la taille de la page définie avec les options. Si vous ne voulez pas couper le contenu de la page, vous pouvez utiliser AdjustToWidestPage de la classe PageSetup. L’exemple suivant montre comment adapter la taille de la page au contenu.

// Render HTML to PDF and adjust to the widest page with Java

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

Options PDF

La classe PdfRenderingOptions offre aux développeurs un contrôle étendu sur le processus de rendu lors de la conversion de HTML en PDF. Elle permet de personnaliser toutes les options générales et propose en outre des options spécifiques au rendu au format PDF : DocumentInfo, Encryption, FormFieldBehaviour et JpegQuality.

L’exemple suivant illustre la fonctionnalité de définition des autorisations pour un fichier PDF.

// Render HTML to PDF with password protection using Java

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

Options d’image

ImageRenderingOptions vous permet de personnaliser un large éventail de paramètres allant du lissage (anticrénelage) à la compression de l’image en passant par la résolution et les formats. L’exemple suivant montre comment modifier la résolution et l’anticrénelage de l’image obtenue :

// Render HTML to JPG with custom resolution and antialiasing settings with Java

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

Renderers

Alors que la méthode renderTo(device) de la classe Document vous permet d’envoyer un seul document au périphérique de rendu de sortie, l’utilisation directe des instances Renderer vous permet d’envoyer plusieurs fichiers à la fois. Aspose.HTML for Java fournit l’implémentation suivante des moteurs de rendu : HtmlRenderer, SvgRenderer, MhtmlRenderer et EpubRenderer, qui sont utilisés pour rendre les documents HTML, SVG, MHTML et EPUB, respectivement.

L’exemple suivant montre comment utiliser HtmlRenderer pour rendre plusieurs documents HTML :

// Merge HTML to PDF using Java

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

Définir le délai d’attente

Une autre fonction importante disponible pour les moteurs de rendu est le réglage du délai d’attente. Vous pouvez l’utiliser pour spécifier la durée pendant laquelle vous êtes prêt à attendre que tous les processus internes liés au cycle de vie d’un document soient terminés, tels que le chargement des ressources, les minuteries actives, etc. Bien sûr, vous pouvez spécifier une période d’attente infinie. Bien sûr, vous pouvez spécifier une période d’attente infinie. Cependant, si le document contient un script avec une boucle sans fin, vous attendrez indéfiniment. L’exemple ci-dessous montre comment utiliser la méthode render(device, timeout, documents) avec le paramètre timeout :

// Render HTML to PDF with timeout settings using Java

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

Conclusion

Aspose.HTML for Java est une bibliothèque puissante et flexible pour le rendu de HTML, MHTML, EPUB et SVG vers différents formats, tels que PDF, XPS, DOCX et images. La classe Converter est rapide et facile à utiliser pour les tâches simples. Cependant, si vous avez besoin de plus de contrôle sur les options de rendu, utilisez la méthode renderTo(device).

Grâce à un large éventail d’options de rendu et de fonctions configurables, les développeurs ont un contrôle total sur la sortie, y compris la résolution, les paramètres de page, les types de médias CSS et les configurations spécifiques à l’appareil. La flexibilité de l’API, démontrée par la possibilité d’utiliser plusieurs moteurs de rendu, de configurer des options générales et spécifiques au format, et même de gérer les délais d’attente, en fait un excellent choix pour créer des documents personnalisés de haute qualité.