Konverter zur Feinabstimmung – Konvertieren von HTML, MHTML, EPUB und SVG in Java

Mit Aspose.HTML for Java können Sie HTML auf verschiedene Arten in verschiedene gängige Formate konvertieren:

• Durch die Verwendung der convertHTML() Methoden der Klasse Converter. Dies ist die gebräuchlichste Methode, um HTML in verschiedene Formate zu konvertieren.
• Durch Verwendung der Methode renderTo(device) der Klasse HTMLDocument oder der Methode render() der Klasse Renderer. Diese alternative Methode zum Rendern von HTML-Dokumenten kann Ihnen mehr Kontrolle über den HTML-Rendering-Prozess in Ihrer Java-Anwendung geben.

Rendering-Gerät

Das Rendering-(Ausgabe-)Gerät kapselt eine 2D-Zeichenfläche, deren API über die Schnittstelle IDevice implementiert wird. Derzeit implementiert Aspose.HTML for Java API eine Reihe von Rendering-Geräten – PdfDevice, XpsDevice, DocDevice und ImageDevice, die zur Erzeugung von PDF-, XPS-, DOCX- bzw. Bilddateiformaten verwendet werden.

Das nächste Beispiel zeigt, wie das PdfDevice verwendet wird, um ein HTML-Dokument in eine PDF-Datei umzuwandeln. Der Prozess erfolgt mit den Standard-Rendering-Optionen:

1. Laden Sie ein HTML-Dokument.
2. Erstellen Sie eine Instanz der PdfDevice-Klasse mit einem der PdfDevice() Konstruktoren.
3. Aufruf der Methode renderTo(device) der Klasse 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);

Rendering-Optionen

Rendering-Optionen geben Ihnen zusätzliche Kontrolle über das Ausgabegerät. Jedes Rendering-Gerät PdfDevice, XpsDevice und ImageDevice hat einen eigenen Satz von Optionen, die mit den Klassen PdfRenderingOptions, XpsRenderingOptions, DocRenderingOptions bzw. ImageRenderingOptions implementiert sind. Sie können z. B. die Seitengröße ändern, die Ränder und die Hintergrundfarbe anpassen, die Dateigröße durch Anpassung der Bildqualität und -auflösung verringern, ein Sicherheitskennwort festlegen, wenn Sie PdfDevice verwenden, usw.

Nachfolgend wird demonstriert, wie die Seitengröße bei der Umwandlung von HTML in PDF mithilfe von PdfRenderingOptions angepasst werden kann:

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

Allgemeine Optionen

Rendering Options gibt Ihnen zusätzliche Kontrolle über das Ausgabegerät. Das Paket com.aspose.html.rendering besteht aus zahlreichen Renderer-Objekten und entsprechenden Low-Level-Optionen-Klassen, die für das Rendering von Dokumenten in der IDevice-Implementierung verantwortlich sind. Die Klassen RenderingOptions und CssOptions repräsentieren Rendering-Optionen, oder mit anderen Worten, allgemeine Rendering-Optionen.

die Allgemeinen Optionen gelten für alle Rendering-Geräte und alle Rendering-Verfahren von HTML bis PDF, XPS, DOCX und Bilder. Schauen wir uns einige von ihnen an:

Horizontale und vertikale Auflösung

Die Einstellungen für die horizontale und vertikale Auflösung sind entscheidend für eine qualitativ hochwertige Ausgabe beim Rendern von HTML in andere Formate, z. B. HTML in PDF. Horizontale und vertikale Auflösungen werden in Pixeln pro Zoll (dpi) gemessen (abrufen und einstellen), mit einem Standardwert von 300 dpi. Diese Einstellung gewährleistet scharfe Details und eine gleichmäßige Darstellung von Elementen wie Text, Bildern und horizontalen und vertikalen Linien in PDF.

Das folgende Beispiel zeigt, wie die Auflösung der resultierenden PDF-Datei gesteuert werden kann, was sich letztlich auf ihre Größe und Qualität auswirkt:

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

CSS Media Type

Der CSS-Medientyp ist ein wichtiges Merkmal, das angibt, wie ein Dokument auf verschiedenen Medien dargestellt werden soll: auf dem Bildschirm, auf Papier, mit einer Blindenschriftvorrichtung usw. Es gibt nur wenige Möglichkeiten, den Medientyp für eine Stilvorlage festzulegen: über verknüpfte Stilvorlagen oder Inline-Stilvorlagen:

Linked Style Sheet

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

Inline Style Sheet

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

Aspose.HTML for Java unterstützt diese Funktion, so dass Sie HTML-Dokumente so konvertieren können, wie sie auf dem Bildschirm oder im Druck aussehen, indem Sie die entsprechenden Medientypen und Stilvorlagen anwenden. Das folgende Beispiel zeigt, wie man den Medientyp einrichtet:

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

Bitte beachten Sie, dass der Standardwert von CssOptions.MediaType Print ist. Dies bedeutet, dass das Dokument unter Anwendung von Stilvorlagen für das Druckgerät konvertiert wird und wie auf Papier aussieht (Sie können die Druckvorschau Ihres Browsers verwenden, um den Unterschied zu sehen). Wenn Sie möchten, dass das Dokument so aussieht, wie es auf dem Bildschirm dargestellt wird, sollten Sie MediaType.Screen verwenden.

Hintergrundfarbe - Background Color

Die Einstellung Hintergrundfarbe ist eine wichtige Funktion zur Anpassung des Erscheinungsbildes des gerenderten Dokuments. Sie ermöglicht es Entwicklern, die Farbe festzulegen, mit der der Hintergrund jeder Seite in der Ausgabedatei gefüllt werden soll. Standardmäßig ist diese Eigenschaft auf Transparent eingestellt, was bedeutet, dass der Hintergrund keine sichtbare Füllung hat, es sei denn, dies wird ausdrücklich angegeben. Die Anpassung der Hintergrundfarbe kann die Lesbarkeit eines Dokuments verbessern, Branding-Anforderungen erfüllen oder visuell ansprechende Designs erstellen.

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

Seite einrichten - Page Setup

Die Seiteneinrichtung ist eine Reihe von Parametern, die das Layout einer gedruckten Seite bestimmen. Diese Parameter umfassen alles von der Seitengröße, den Rändern und der automatischen Größenanpassung bis hin zu den @Seitenprioritätsregeln. Mithilfe dieser Parameter können Sie problemlos ein individuelles Layout für jede Seite einrichten.

In einigen Fällen kann der Inhalt der HTML-Seite breiter sein als die mit den Optionen festgelegte Seitengröße. Wenn Sie den Seiteninhalt nicht abschneiden wollen, können Sie AdjustToWidestPage der Klasse PageSetup verwenden. Das folgende Beispiel zeigt, wie man die Seitengröße an den Inhalt anpasst.

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

PDF-Optionen

Die Klasse PdfRenderingOptions gibt Entwicklern umfassende Kontrolle über den Rendering-Prozess bei der Konvertierung von HTML in PDF. Sie ermöglicht die Anpassung aller allgemeinen Optionen und bietet darüber hinaus spezielle Optionen für die Umwandlung in das PDF-Format – DocumentInfo, Encryption, FormFieldBehaviour und JpegQuality.

Das folgende Beispiel veranschaulicht die Funktionalität des Festlegens von Berechtigungen für eine PDF-Datei.

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

Bild-Optionen

mit ImageRenderingOptions können Sie eine Vielzahl von Einstellungen vornehmen, von der Glättung (Antialiasing) über die Bildauflösung und -formate bis hin zur Bildkompression. Das folgende Beispiel zeigt, wie die Auflösung und das Antialiasing für das Ergebnisbild geändert werden können:

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

Renderer

Während die renderTo(device) Methode der Document Klasse Ihnen die Möglichkeit gibt, ein einzelnes Dokument an das Ausgabegerät zu senden, können Sie mit den Renderer Instanzen direkt mehrere Dateien auf einmal senden. Aspose.HTML for Java bietet die folgende Implementierung von Renderern: HtmlRenderer, SvgRenderer, MhtmlRenderer und EpubRenderer, die jeweils zum Rendern von HTML-, SVG-, MHTML- und EPUB-Dokumenten verwendet werden.

Das nächste Beispiel zeigt, wie man HtmlRenderer verwendet, um mehrere HTML-Dokumente zu rendern:

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

Zeitüberschreitung einstellen

Eine weitere wichtige Funktion, die für Renderer zur Verfügung steht, ist die Einstellung der Zeitüberschreitung. Damit können Sie festlegen, wie lange Sie warten wollen, bis alle internen Prozesse im Zusammenhang mit dem Lebenszyklus eines Dokuments abgeschlossen sind, z. B. das Laden von Ressourcen, aktive Zeitgeber usw. Natürlich können Sie eine unendliche Wartezeit angeben. Wenn das Dokument jedoch ein Skript mit einer Endlosschleife enthält, werden Sie unendlich lange warten müssen. Das folgende Beispiel zeigt, wie man die Methode render(device, timeout, documents mit dem Parameter timeout verwendet:

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

Schlussfolgerung

Aspose.HTML for Java ist eine leistungsfähige und flexible Bibliothek für die Umwandlung von HTML, MHTML, EPUB und SVG in verschiedene Formate wie PDF, XPS, DOCX und Bilder. Die Klasse Converter ist schnell und einfach zu benutzen für einfache Aufgaben. Wenn Sie jedoch mehr Kontrolle über die Rendering-Optionen benötigen, verwenden Sie die Methode renderTo(device).

Mit einer breiten Palette von Rendering-Optionen und konfigurierbaren Funktionen haben Entwickler die volle Kontrolle über die Ausgabe, einschließlich Auflösung, Seiteneinstellungen, CSS-Medientypen und gerätespezifische Konfigurationen. Die Flexibilität der API, die sich in der Möglichkeit zeigt, mehrere Renderer zu verwenden, allgemeine und formatspezifische Optionen zu konfigurieren und sogar Timeouts zu verwalten, macht sie zu einer hervorragenden Wahl für die Erstellung hochwertiger, benutzerdefinierter Dokumente.