From eb24c054a0ad1a615366e84a65256ae0d4482055 Mon Sep 17 00:00:00 2001 From: Muhammad Adil Date: Wed, 8 Jul 2026 22:26:37 +0000 Subject: [PATCH] Add 1 html java tutorials MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Categories: saving-html-documents Source: AI Search API Tutorials: - Save Generated HTML Result – Full Template Processing Guide Auto-generated by Professionalize.Tutorials Agent --- .../java/saving-html-documents/_index.md | 4 +- .../_index.md | 281 +++++++++++++++++ .../java/saving-html-documents/_index.md | 5 +- .../_index.md | 278 +++++++++++++++++ .../java/saving-html-documents/_index.md | 5 +- .../_index.md | 273 +++++++++++++++++ .../java/saving-html-documents/_index.md | 5 +- .../_index.md | 284 +++++++++++++++++ .../java/saving-html-documents/_index.md | 6 +- .../_index.md | 284 +++++++++++++++++ .../og-image.png | Bin 0 -> 51119 bytes .../java/saving-html-documents/_index.md | 5 +- .../_index.md | 284 +++++++++++++++++ .../java/saving-html-documents/_index.md | 5 +- .../_index.md | 282 +++++++++++++++++ .../java/saving-html-documents/_index.md | 5 +- .../_index.md | 283 +++++++++++++++++ .../java/saving-html-documents/_index.md | 7 +- .../_index.md | 272 +++++++++++++++++ .../java/saving-html-documents/_index.md | 5 +- .../_index.md | 278 +++++++++++++++++ .../java/saving-html-documents/_index.md | 6 +- .../_index.md | 285 ++++++++++++++++++ .../java/saving-html-documents/_index.md | 5 +- .../_index.md | 284 +++++++++++++++++ .../java/saving-html-documents/_index.md | 5 +- .../_index.md | 283 +++++++++++++++++ .../java/saving-html-documents/_index.md | 5 +- .../_index.md | 278 +++++++++++++++++ .../java/saving-html-documents/_index.md | 8 +- .../_index.md | 279 +++++++++++++++++ .../java/saving-html-documents/_index.md | 5 +- .../_index.md | 282 +++++++++++++++++ .../java/saving-html-documents/_index.md | 4 +- .../_index.md | 282 +++++++++++++++++ .../java/saving-html-documents/_index.md | 6 +- .../_index.md | 273 +++++++++++++++++ .../java/saving-html-documents/_index.md | 4 +- .../_index.md | 272 +++++++++++++++++ .../java/saving-html-documents/_index.md | 5 +- .../_index.md | 284 +++++++++++++++++ .../thai/java/saving-html-documents/_index.md | 4 +- .../_index.md | 268 ++++++++++++++++ .../java/saving-html-documents/_index.md | 4 +- .../_index.md | 281 +++++++++++++++++ .../java/saving-html-documents/_index.md | 4 +- .../_index.md | 271 +++++++++++++++++ 47 files changed, 6509 insertions(+), 29 deletions(-) create mode 100644 html/arabic/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/chinese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/czech/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/dutch/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/english/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/english/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/og-image.png create mode 100644 html/french/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/german/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/greek/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/hindi/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/hongkong/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/hungarian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/indonesian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/italian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/japanese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/korean/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/polish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/portuguese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/russian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/spanish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/swedish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/thai/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/turkish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md create mode 100644 html/vietnamese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md diff --git a/html/arabic/java/saving-html-documents/_index.md b/html/arabic/java/saving-html-documents/_index.md index 932c0a8542..241dcb3910 100644 --- a/html/arabic/java/saving-html-documents/_index.md +++ b/html/arabic/java/saving-html-documents/_index.md @@ -54,9 +54,11 @@ url: /ar/java/saving-html-documents/ تعرف على كيفية حفظ مستندات HTML بتنسيق MHTML باستخدام Aspose.HTML لـ Java من خلال هذا الدليل خطوة بخطوة، والذي يشتمل على أمثلة التعليمات البرمجية والنصائح العملية. ### [حفظ مستند SVG في Aspose.HTML لـ Java](./save-svg-document/) تعرف على كيفية حفظ مستندات SVG باستخدام Aspose.HTML لـ Java من خلال هذا الدليل السهل خطوة بخطوة والمليء بالأمثلة. +### [حفظ نتيجة HTML المُولَّدة – دليل معالجة القالب الكامل](./save-generated-html-result-full-template-processing-guide/) + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/arabic/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/arabic/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..a2607b0ba4 --- /dev/null +++ b/html/arabic/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,281 @@ +--- +category: general +date: 2026-07-08 +description: احفظ نتيجة HTML المولدة بسهولة مع هذا الدليل خطوة بخطوة الذي يرشّك عبر + تحميل البيانات، ومعالجة قالب HTML، وكتابة الملف النهائي. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: ar +lastmod: 2026-07-08 +og_description: احفظ نتيجة HTML المُولدة بسرعة. يوضح لك هذا الدليل كيفية تحميل مصدر + البيانات، ربطه بقالب HTML، معالجة القالب، وكتابة ملف الإخراج. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: حفظ نتيجة HTML المُولَّدة – دليل القالب خطوة بخطوة +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: حفظ نتيجة HTML المُولَّدة – دليل كامل لمعالجة القوالب +url: /ar/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# حفظ نتيجة HTML المُولَّدة – دليل معالجة القالب الكامل + +هل تساءلت يومًا كيف **تحفظ نتيجة HTML المُولَّدة** دون أن تشعر بالإحباط؟ لست وحدك. سواء كنت تبني مولِّد مواقع ثابتة، أو محرك قوالب بريد إلكتروني، أو تحتاج فقط إلى تفريغ بعض البيانات في صفحة منسقة بشكل جميل، فإن الخطوات بسيطة بشكل مفاجئ بمجرد تقسيمها. + +في هذا الدرس سنستعرض كل مرحلة — من **تحميل مصدر البيانات** إلى **ربط قالب HTML**، ثم **معالجة القالب**، وأخيرًا **حفظ نتيجة HTML المُولَّدة**. في النهاية ستحصل على برنامج Java جاهز للتنفيذ ينتج ملف `result.html` مُعبَّأ في مجلد مشروعك. + +## ما ستتعلمه + +- كيفية قراءة بيانات XML أو JSON باستخدام فئة مساعدة صغيرة. +- كيفية تحميل ملف HTML يحتوي على نواقل `${...}`. +- كيف يقوم `TemplateProcessor` المدمج باستبدال تلك النواقل بقيم حقيقية. +- كيفية كتابة HTML النهائي إلى القرص حتى تتمكن الأنظمة الأخرى من استهلاكه. + +لا مكتبات خارجية، لا سحر غامض — مجرد Java عادي وبعض الفئات البديهية. افتح بيئة التطوير المفضلة لديك (IntelliJ، Eclipse، أو حتى VS Code) ولنبدأ. + +--- + +## نظرة عامة على حفظ نتيجة HTML المُولَّدة + +قبل الغوص في الشيفرة، تخيل خط الأنابيب الكامل: + +1. **تحميل مصدر البيانات** – XML أو JSON يحتوي القيم الديناميكية. +2. **تحميل قالب HTML** – ملف ثابت يحتوي على تعبيرات ربط البيانات. +3. **معالجة القالب** – استبدال كل تعبير بالقيمة المطابقة. +4. **حفظ نتيجة HTML المُولَّدة** – كتابة العلامات المعبَّأة إلى ملف جديد. + +فكر فيها كخط تجميع بسيط: مادة خام (بيانات) → مخطط (قالب) → منتج نهائي (HTML). كل مرحلة مستقلة، مما يجعل الاختبار وتصحيح الأخطاء سهلًا. + +--- + +### الخطوة 1: تحميل مصدر البيانات + +أول ما نحتاجه هو حاوية تعرف كيف تقرأ إما XML أو JSON. في هذا المثال سنبقى مع XML لأنه سهل التصور، لكن استبداله بـ JSON مجرد تغيير فئة واحدة. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**لماذا هذا مهم:** تحميل مصدر البيانات مبكرًا يمنحنا مصدرًا وحيدًا للحقيقة لكل النواقل. إذا كان XML غير صالح، سنعرف ذلك فورًا — لا أخطاء غامضة لاحقًا عندما يحاول القالب ربط القيم. + +> **نصيحة احترافية:** حافظ على نظافة XML وتجنب التعشيق العميق؛ الهياكل المسطحة تُطابق نواقل `${field}` بشكل أنظف. + +--- + +### الخطوة 2: تحميل قالب HTML (ربط قالب HTML) + +الآن نقوم بتحميل ملف HTML الثابت الذي يحتوي على تعبيرات الربط. النواقل تتبع صيغة `${key}`، والتي يتعرف عليها المعالج تلقائيًا. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**لماذا نفعل ذلك بهذه الطريقة:** بالحفاظ على القالب الأصلي دون تعديل، يمكنك إعادة استخدام نفس الملف لمجموعات بيانات متعددة. كما يسهل ذلك اختبار وحدة المعالج: أرسل له سلسلة نصية، تحقق من النتيجة، ولن تحتاج إلى لمس نظام الملفات مرة أخرى. + +--- + +### الخطوة 3: معالجة القالب (معالجة القالب) + +الآن يأتي جوهر العملية: استبدال النواقل بالقيم الحقيقية. `TemplateProcessor` يتجول في DOM الذي حمّلناه مسبقًا، يستخرج القيم، ويحقنها في سلسلة HTML. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**ما الذي يحدث خلف الكواليس؟** المعالج يمر على كل عنصر في مستند XML، يُنشئ رمز `${key}`، ويُجري استبدالًا بسيطًا بـ `String.replace`. ليس الأكثر كفاءة للملفات الضخمة، لكن لسيناريوهات القوالب المعتادة هو كافٍ ويجعل الشيفرة قابلة للقراءة. + +> **ملاحظة حالة حافة:** إذا ظهر الناقل أكثر من مرة، سيتعامل `replace` مع جميع التكرارات. إذا كان المفتاح مفقودًا في XML، يبقى الرمز كما هو — ما يُسهل اكتشاف البيانات الناقصة أثناء اختبار الجودة. + +--- + +### الخطوة 4: حفظ نتيجة HTML المُولَّدة + +أخيرًا، نقوم بحفظ العلامات المعبَّأة إلى القرص. هنا يبرز فعليًا مفهوم **حفظ نتيجة HTML المُولَّدة**. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**لماذا يهمك ذلك:** كتابة الملف هي الخطوة الأخيرة والحاسمة. بمجرد أن يصبح HTML على القرص يمكنك خدمته عبر خادم ويب، إرساله إلى محول PDF، أو إرساله كرسالة إخبارية. طريقة `save` تخفي تفاصيل I/O، لذا يبقى منطقك الرئيسي نظيفًا ومركزًا على التحويل. + +--- + +## أسئلة شائعة ونصائح + +- **هل يمكنني استخدام JSON بدلاً من XML؟** + بالتأكيد. استبدل `TemplateData` بفئة تقوم بتحليل JSON (مثلاً `ObjectMapper` من Jackson) وعدل طريقة `process` لقراءة أزواج المفتاح/القيمة من `Map`. + +- **ماذا لو احتوت نواقل القالب على مسافات أو أحرف خاصة** + (النص الأصلي غير مكتمل؛ يُرجى إكمال الشرح حسب الحاجة.) + +## ما الذي يجب أن تتعلمه بعد ذلك؟ + +الدروس التالية تغطي مواضيع ذات صلة وثيقة تبني على التقنيات الموضحة في هذا الدليل. كل مورد يتضمن أمثلة شيفرة كاملة مع شروحات خطوة بخطوة لمساعدتك على إتقان ميزات API إضافية واستكشاف أساليب تنفيذ بديلة في مشاريعك. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/chinese/java/saving-html-documents/_index.md b/html/chinese/java/saving-html-documents/_index.md index 4416df17e6..e40733b768 100644 --- a/html/chinese/java/saving-html-documents/_index.md +++ b/html/chinese/java/saving-html-documents/_index.md @@ -54,9 +54,12 @@ url: /zh/java/saving-html-documents/ 通过本分步指南（其中包含代码示例和实用技巧），了解如何使用 Aspose.HTML for Java 将 HTML 文档保存为 MHTML。 ### [在 Aspose.HTML for Java 中保存 SVG 文档](./save-svg-document/) 通过本包含示例的简单分步指南学习如何使用 Aspose.HTML for Java 保存 SVG 文档。 +### [保存生成的 HTML 结果 – 完整模板处理指南](./save-generated-html-result-full-template-processing-guide/) +通过本分步指南学习如何使用 Aspose.HTML for Java 保存生成的 HTML 结果并完成完整的模板处理。 + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/chinese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/chinese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..3807eecb6d --- /dev/null +++ b/html/chinese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,278 @@ +--- +category: general +date: 2026-07-08 +description: 通过本分步教程轻松保存生成的 HTML 结果，教程将引导您完成加载数据、处理 HTML 模板以及写入最终文件的过程。 +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: zh +lastmod: 2026-07-08 +og_description: 快速保存生成的 HTML 结果。本指南展示如何加载数据源，将其绑定到 HTML 模板，处理模板，并写入输出文件。 +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: 保存生成的HTML结果 – 步骤式模板指南 +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: 保存生成的 HTML 结果 – 完整模板处理指南 +url: /zh/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# 保存生成的 HTML 结果 – 完整模板处理指南 + +有没有想过如何在不抓狂的情况下**保存生成的 HTML 结果**？你并不是唯一有此困惑的人。无论你是在构建静态站点生成器、邮件模板引擎，还是仅仅需要将一些数据导出到格式良好的页面，这些步骤在拆解后其实非常简单。 + +在本教程中，我们将逐步演示每个阶段——从**加载数据源**到**HTML 模板绑定**，再到**处理模板**，最后**保存生成的 HTML 结果**。完成后，你将拥有一个可直接运行的 Java 程序，能够在项目文件夹中生成填充好的 `result.html` 文件。 + +## 你将学到什么 + +- 如何使用一个小型辅助类读取 XML 或 JSON 数据。 +- 如何加载包含 `${...}` 样式占位符的 HTML 文件。 +- 内置的 `TemplateProcessor` 如何将这些占位符替换为真实值。 +- 如何将最终的 HTML 写入磁盘，以便其他系统使用。 + +无需外部库，也不需要神秘的魔法——只需纯 Java 和几个直观的类。打开你喜欢的 IDE（IntelliJ、Eclipse，甚至 VS Code），让我们开始吧。 + +--- + +## 保存生成的 HTML 结果 – 概述 + +在深入代码之前，让我们先想象整个流水线： + +1. **加载数据源** – 包含动态值的 XML 或 JSON。 +2. **加载 HTML 模板** – 带有数据绑定表达式的静态文件。 +3. **处理模板** – 用匹配的数据替换每个表达式。 +4. **保存生成的 HTML 结果** – 将填充后的标记写入新文件。 + +可以把它想象成一个简单的装配线：原材料（数据）→ 蓝图（模板）→ 成品（HTML）。每个阶段相互独立，这使得测试和调试轻而易举。 + +--- + +### 步骤 1：加载数据源 + +我们首先需要一个能够读取 XML 或 JSON 的容器。在本例中我们使用 XML，因为它更易于直观展示，但如果想换成 JSON，只需更改一个类即可。 + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**为什么这很重要：** 及早加载数据源可以为所有占位符提供唯一的真实来源。如果 XML 格式错误，我们会立刻发现——避免在模板绑定值时出现神秘的 bug。 + +> **专业提示：** 保持 XML 整洁，避免深层嵌套；扁平结构更容易映射到 `${field}` 占位符。 + +--- + +### 步骤 2：加载 HTML 模板（HTML 模板绑定） + +接下来我们读取包含绑定表达式的静态 HTML 文件。占位符遵循 `${key}` 语法，处理器会自动识别。 + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**为什么这样做：** 保持原始模板不被修改，你可以将同一文件用于多个数据集。这也让对处理器的单元测试更容易：提供一个字符串，验证输出，而无需再次操作文件系统。 + +--- + +### 步骤 3：处理模板（Process Template） + +现在进入操作的核心：用真实值替换占位符。`TemplateProcessor` 遍历我们之前加载的 DOM，提取值并注入到 HTML 字符串中。 + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**内部工作原理是什么？** 处理器遍历 XML 文档中的每个元素，构建 `${key}` 令牌，并执行简单的 `String.replace`。虽然对超大文件来说性能不是最优，但对典型的模板场景已经足够，并且代码易读。 + +> **边缘情况说明：** 如果占位符出现多次，`replace` 会处理所有出现。若 XML 中缺少某个键，令牌将保持原样——这有助于在 QA 时发现缺失的数据。 + +--- + +### 步骤 4：保存生成的 HTML 结果 + +最后，我们将填充好的标记持久化到磁盘。这正是**保存生成的 HTML 结果**这句话真正发挥作用的地方。 + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**为什么这很重要：** 写入文件是最后且决定性的操作。HTML 写入磁盘后，你可以用 Web 服务器提供它，送入 PDF 转换器，或作为新闻通讯通过邮件发送。`save` 方法封装了 I/O 核心代码，使得主逻辑保持简洁，专注于转换。 + +--- + +## 常见问题与技巧 + +- **我可以使用 JSON 替代 XML 吗？** + 当然可以。将 `TemplateData` 替换为解析 JSON 的类（Jackson 的 `ObjectMapper` 使用良好），并调整 `process` 方法以从 `Map` 读取键/值对。 + +- **如果我的占位符包含空格或特殊字符怎么办** + +## 接下来你应该学习什么？ + +以下教程涵盖与本指南紧密相关的主题，基于本教程展示的技术。每个资源都包含完整的可运行代码示例和逐步解释，帮助你掌握更多 API 功能，并在自己的项目中探索替代实现方案。 + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/czech/java/saving-html-documents/_index.md b/html/czech/java/saving-html-documents/_index.md index 11b56c92a0..2a35f2f6c9 100644 --- a/html/czech/java/saving-html-documents/_index.md +++ b/html/czech/java/saving-html-documents/_index.md @@ -54,9 +54,12 @@ Snadno převeďte HTML na Markdown pomocí Aspose.HTML pro Java. Postupujte podl Naučte se ukládat HTML dokumenty jako MHTML pomocí Aspose.HTML for Java pomocí tohoto podrobného průvodce, doplněného příklady kódu a praktickými tipy. ### [Uložte dokument SVG v Aspose.HTML pro Java](./save-svg-document/) Naučte se ukládat dokumenty SVG pomocí Aspose.HTML for Java pomocí tohoto jednoduchého podrobného průvodce plného příkladů. +### [Uložit vygenerovaný HTML výsledek – Kompletní průvodce zpracováním šablony](./save-generated-html-result-full-template-processing-guide/) +Naučte se uložit vygenerovaný HTML výsledek pomocí plného zpracování šablony v Aspose.HTML pro Java. + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/czech/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/czech/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..9e370ce97d --- /dev/null +++ b/html/czech/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,273 @@ +--- +category: general +date: 2026-07-08 +description: Uložte vygenerovaný výsledek HTML snadno pomocí tohoto krok‑za‑krokem + tutoriálu, který vás provede načítáním dat, zpracováním HTML šablony a zápisem finálního + souboru. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: cs +lastmod: 2026-07-08 +og_description: Rychle uložte vygenerovaný HTML výsledek. Tento průvodce vám ukáže, + jak načíst zdroj dat, svázat jej s HTML šablonou, zpracovat šablonu a zapsat výstupní + soubor. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Uložte vygenerovaný HTML výsledek – Průvodce šablonou krok po kroku +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Uložení vygenerovaného HTML výsledku – Kompletní průvodce zpracováním šablon +url: /cs/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Uložení vygenerovaného HTML výsledku – Kompletní průvodce zpracováním šablony + +Už jste se někdy zamysleli, jak **uložit vygenerovaný HTML výsledek** bez toho, abyste si trhali vlasy? Nejste v tom sami. Ať už budujete statický generátor stránek, e‑mailový templating engine, nebo jen potřebujete vypsat nějaká data na hezky naformátovanou stránku, kroky jsou překvapivě jednoduché, když je rozdělíte na jednotlivé části. + +V tomto tutoriálu projdeme každý krok – od **load data source** po **HTML template binding**, pak **process template** a nakonec **save generated HTML result**. Na konci budete mít připravený spustitelný Java program, který vytvoří vyplněný soubor `result.html` ve vašem projektovém adresáři. + +## Co se naučíte + +- Jak načíst XML nebo JSON data pomocí malé pomocné třídy. +- Jak načíst HTML soubor, který obsahuje zástupné znaky ve stylu `${...}`. +- Jak vestavěný `TemplateProcessor` nahrazuje tyto zástupné znaky skutečnými hodnotami. +- Jak zapsat finální HTML na disk, aby ho mohly využívat další systémy. + +Žádné externí knihovny, žádná tajemná magie – jen čistá Java a pár intuitivních tříd. Vemte si svůj oblíbený IDE (IntelliJ, Eclipse nebo i VS Code) a pojďme na to. + +--- + +## Přehled ukládání vygenerovaného HTML výsledku + +Než se ponoříme do kódu, představme si celý proces: + +1. **Load the data source** – XML nebo JSON, který obsahuje dynamické hodnoty. +2. **Load the HTML template** – statický soubor s výrazy pro datové vazby. +3. **Process the template** – nahradit každý výraz odpovídajícími daty. +4. **Save the generated HTML result** – zapsat vyplněný markup do nového souboru. + +Představte si to jako jednoduchou montážní linku: surovina (data) → nákres (šablona) → hotový produkt (HTML). Každá fáze je nezávislá, což usnadňuje testování i ladění. + +### Krok 1: Načtení zdroje dat + +První, co potřebujeme, je kontejner, který umí načíst buď XML, nebo JSON. V tomto příkladu zůstáváme u XML, protože je snadno představitelné, ale přepnutí na JSON je jen otázkou výměny jedné třídy. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Proč je to důležité:** Načtení zdroje dat hned na začátku nám poskytuje jediný zdroj pravdy pro všechny zástupné znaky. Pokud je XML poškozené, zjistíme to okamžitě – žádné záhadné chyby později, až šablona začne hodnoty vázat. + +> **Tip:** Udržujte XML přehledné a vyhněte se hlubokému vnoření; ploché struktury se čistěji mapují na `${field}` zástupné znaky. + +### Krok 2: Načtení HTML šablony (HTML Template Binding) + +Dále načteme statický HTML soubor, který obsahuje výrazy pro vazbu. Zástupné znaky používají syntaxi `${key}`, kterou procesor rozpozná automaticky. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Proč to děláme takto:** Tím, že ponecháme původní šablonu nedotčenou, můžete stejný soubor znovu použít pro různé datové sady. Navíc to usnadňuje unit‑testování procesoru: předáte mu řetězec, ověříte výstup a už se nemusíte dotýkat souborového systému. + +### Krok 3: Zpracování šablony (Process Template) + +Nyní přichází jádro operace: výměna zástupných znaků za skutečné hodnoty. `TemplateProcessor` prochází DOM, který jsme načetli dříve, získává hodnoty a vkládá je do HTML řetězce. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**Co se děje pod kapotou?** Procesor iteruje přes každý prvek v XML dokumentu, vytvoří token `${key}` a provede jednoduchý `String.replace`. Není to nejvýkonnější řešení pro obrovské soubory, ale pro typické scénáře šablon je více než dostačující a kód zůstává čitelný. + +> **Poznámka k okrajovému případu:** Pokud se zástupný znak objeví vícekrát, `replace` zvládne všechny výskyty. Pokud v XML chybí klíč, token zůstane nezměněn – skvělé pro odhalování chybějících dat během QA. + +### Krok 4: Uložení vygenerovaného HTML výsledku + +Nakonec uložíme vyplněný markup na disk. Zde se opravdu projevuje fráze **save generated HTML result**. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Proč by vás to mělo zajímat:** Zapsání souboru je poslední, rozhodující krok. Jakmile je HTML na disku, můžete ho naservírovat webovým serverem, předat PDF konvertoru nebo rozeslat jako newsletter. Metoda `save` skrývá I/O boilerplate, takže hlavní logika zůstává čistá a soustředěná na transformaci. + +## Časté otázky a tipy + +- **Mohu místo XML použít JSON?** + Určitě. Nahraďte `TemplateData` třídou, která parsuje JSON (např. Jackson `ObjectMapper`) a upravte metodu `process`, aby četla páry klíč/hodnota z `Map`. + +- **Co když moje zástupné znaky obsahují mezery nebo speciální znaky?** + V takovém případě je dobré použít jiný formát nebo upravit regulární výraz v procesoru, aby rozpoznal i tyto varianty. Alternativně můžete v XML/JSON klíče normalizovat (např. `first_name` místo `first name`). + +## Co byste se měli naučit dál? + +Následující tutoriály pokrývají úzce související témata, která staví na technikách předvedených v tomto průvodci. Každý zdroj obsahuje kompletní funkční ukázky kódu s podrobnými vysvětleními, abyste si osvojili další funkce API a prozkoumali alternativní implementační přístupy ve svých projektech. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/dutch/java/saving-html-documents/_index.md b/html/dutch/java/saving-html-documents/_index.md index fadf7ac490..73519bff93 100644 --- a/html/dutch/java/saving-html-documents/_index.md +++ b/html/dutch/java/saving-html-documents/_index.md @@ -54,9 +54,12 @@ Converteer HTML eenvoudig naar Markdown met Aspose.HTML voor Java. Volg deze sta Leer hoe u HTML-documenten als MHTML kunt opslaan met Aspose.HTML voor Java met deze stapsgewijze handleiding, compleet met codevoorbeelden en praktische tips. ### [SVG-document opslaan in Aspose.HTML voor Java](./save-svg-document/) Leer hoe u SVG-documenten kunt opslaan met Aspose.HTML voor Java met deze eenvoudige stapsgewijze handleiding vol voorbeelden. +### [Gegenereerd HTML-resultaat opslaan – Volledige sjabloonverwerkingsgids](./save-generated-html-result-full-template-processing-guide/) +Leer hoe u het gegenereerde HTML-resultaat kunt opslaan met een volledige sjabloonverwerking, inclusief voorbeeldcode en best practices. + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/dutch/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/dutch/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..46e68905de --- /dev/null +++ b/html/dutch/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,284 @@ +--- +category: general +date: 2026-07-08 +description: Sla het gegenereerde HTML‑resultaat eenvoudig op met deze stapsgewijze + tutorial die je begeleidt bij het laden van gegevens, het verwerken van een HTML‑sjabloon + en het schrijven van het uiteindelijke bestand. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: nl +lastmod: 2026-07-08 +og_description: Sla het gegenereerde HTML‑resultaat snel op. Deze gids laat zien hoe + je een gegevensbron laadt, deze bindt aan een HTML‑sjabloon, het sjabloon verwerkt + en het uitvoerbestand schrijft. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Genereerde HTML-resultaat opslaan – Stapsgewijze sjabloongids +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Genereerde HTML-resultaat opslaan – Volledige gids voor sjabloonverwerking +url: /nl/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Gegenereerd HTML-resultaat opslaan – Volledige sjabloonverwerkingsgids + +Heb je je ooit afgevraagd hoe je **gegenereerd HTML-resultaat opslaan** kunt **opslaan** zonder je haar uit je hoofd te trekken? Je bent niet de enige. Of je nu een static site generator, een e‑mail sjabloonengine bouwt, of gewoon wat gegevens in een mooi opgemaakte pagina wilt dumpen, de stappen zijn verrassend eenvoudig zodra je ze opsplitst. + +In deze tutorial lopen we elke fase door—van **load data source** tot **HTML template binding**, vervolgens **process template**, en uiteindelijk **save generated HTML result**. Aan het einde heb je een kant‑klaar Java‑programma dat een gevulde `result.html`‑file in je projectmap produceert. + +--- + +## Wat je zult leren + +- Hoe XML- of JSON-gegevens te lezen met een kleine hulpprogrammaklasse. +- Hoe een HTML‑bestand te laden dat `${...}`‑style placeholders bevat. +- Hoe de ingebouwde `TemplateProcessor` die placeholders vervangt door echte waarden. +- Hoe de uiteindelijke HTML naar schijf te schrijven zodat andere systemen het kunnen gebruiken. + +Geen externe bibliotheken, geen obscure magie—gewoon plain Java en een paar intuïtieve klassen. Pak je favoriete IDE (IntelliJ, Eclipse, of zelfs VS Code) en laten we aan de slag gaan. + +--- + +## Gegenereerd HTML-resultaat opslaan – Overzicht + +Voordat we in de code duiken, laten we de volledige pijplijn visualiseren: + +1. **Load the data source** – XML of JSON die de dynamische waarden bevat. +2. **Load the HTML template** – een statisch bestand met data‑binding expressies. +3. **Process the template** – vervang elke expressie door de bijbehorende data. +4. **Save the generated HTML result** – schrijf de gevulde markup naar een nieuw bestand. + +Beschouw het als een eenvoudige assemblagelijn: ruwe materie (data) → blauwdruk (template) → eindproduct (HTML). Elke fase is onafhankelijk, wat testen en debuggen een fluitje van een cent maakt. + +--- + +### Stap 1: Laad de gegevensbron + +Het eerste wat we nodig hebben is een container die weet hoe XML of JSON gelezen moet worden. In dit voorbeeld blijven we bij XML omdat het gemakkelijk te visualiseren is, maar overschakelen naar JSON is slechts een kwestie van één klasse wijzigen. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Waarom dit belangrijk is:** Het vroeg laden van de gegevensbron geeft ons één bron van waarheid voor alle placeholders. Als de XML niet goed gevormd is, weten we het meteen—geen mysterieuze bugs later wanneer het sjabloon waarden probeert te binden. + +> **Pro tip:** Houd je XML netjes en vermijd diepe nesting; platte structuren mappen schoner naar `${field}` placeholders. + +--- + +### Stap 2: Laad het HTML-sjabloon (HTML Template Binding) + +Vervolgens halen we het statische HTML‑bestand op dat de binding‑expressies bevat. De placeholders volgen de `${key}`‑syntaxis, die de processor automatisch herkent. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Waarom we het op deze manier doen:** Door het originele sjabloon onaangeroerd te laten, kun je hetzelfde bestand hergebruiken voor meerdere datasets. Het maakt ook unit‑testing van de processor makkelijker: geef het een string, verifieer de output, en je hoeft het bestandssysteem nooit meer aan te raken. + +--- + +### Stap 3: Verwerk het sjabloon (Process Template) + +Nu komt het hart van de operatie: placeholders vervangen door echte waarden. De `TemplateProcessor` doorloopt de DOM die we eerder hebben geladen, haalt waarden op, en injecteert ze in de HTML‑string. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**Wat er onder de motorkap gebeurt:** De processor iterereert over elk element in het XML‑document, bouwt een `${key}`‑token, en voert een eenvoudige `String.replace` uit. Het is niet de meest performant voor enorme bestanden, maar voor typische sjabloonscenario's is het meer dan voldoende en houdt de code leesbaar. + +> **Opmerking over randgeval:** Als een placeholder meer dan eens voorkomt, zal `replace` alle voorkomens behandelen. Als een sleutel ontbreekt in de XML, blijft het token onaangeroerd—handig om ontbrekende data tijdens QA te ontdekken. + +--- + +### Stap 4: Gegenereerd HTML-resultaat opslaan + +Tot slot slaan we de gevulde markup op schijf op. Hier komt de uitdrukking **save generated HTML result** echt tot zijn recht. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Waarom dit belangrijk is:** Het schrijven van het bestand is de laatste, beslissende actie. Zodra de HTML op schijf staat, kun je deze serveren met een webserver, naar een PDF‑converter sturen, of als nieuwsbrief e‑mailen. De `save`‑methode verbergt de I/O‑boilerplate, zodat je hoofdlogica schoon blijft en zich richt op de transformatie. + +--- + +## Veelgestelde vragen & tips + +- **Kan ik JSON gebruiken in plaats van XML?** + Absoluut. Vervang `TemplateData` door een klasse die JSON parseert (Jackson’s `ObjectMapper` werkt prima) en pas de `process`‑methode aan om sleutel/waarde‑paren uit een `Map` te lezen. + +- **Wat als mijn placeholders spaties of speciale tekens bevatten** + +## Wat moet je hierna leren? + +De volgende tutorials behandelen nauw verwante onderwerpen die voortbouwen op de technieken die in deze gids worden gedemonstreerd. Elke bron bevat volledige werkende code‑voorbeelden met stap‑voor‑stap uitleg om je te helpen extra API‑functies onder de knie te krijgen en alternatieve implementatie‑benaderingen in je eigen projecten te verkennen. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/english/java/saving-html-documents/_index.md b/html/english/java/saving-html-documents/_index.md index 55b7e5210d..ce1d4bad5e 100644 --- a/html/english/java/saving-html-documents/_index.md +++ b/html/english/java/saving-html-documents/_index.md @@ -41,7 +41,7 @@ You might be wondering, how does this work in practice? Well, it starts with und Speaking of convenience, have you ever considered using MHTML? Saving your HTML document as MHTML can be a lifesaver, especially for sharing content that retains its formatting and links effortlessly across platforms. It’s akin to creating a self-contained book where all the chapters and illustrations are bound together. With Aspose.HTML for Java, this process is straightforward and efficient. -If you’re ready to step into the realm of MHTML, our guide on how to [Save HTML to MHTML in Aspose.HTML for Java](./save-html-to-mhtml/) will walk you through the steps. You’ll not only learn about the syntax but also gain insights into practical usage scenarios that can enhance your projects. +If you're ready to step into the realm of MHTML, our guide on how to [Save HTML to MHTML in Aspose.HTML for Java](./save-html-to-mhtml/) will walk you through the steps. You’ll not only learn about the syntax but also gain insights into practical usage scenarios that can enhance your projects. ## Saving HTML Documents in Aspose.HTML for Java Tutorials ### [Save HTML Document in Aspose.HTML for Java](./save-html-document/) @@ -54,9 +54,11 @@ Easily convert HTML to Markdown using Aspose.HTML for Java. Follow this step-by- Learn how to save HTML documents as MHTML using Aspose.HTML for Java with this step-by-step guide, complete with code examples and practical tips. ### [Save SVG Document in Aspose.HTML for Java](./save-svg-document/) Learn how to save SVG documents using Aspose.HTML for Java with this easy step-by-step guide packed with examples. +### [Save Generated HTML Result – Full Template Processing Guide](./save-generated-html-result-full-template-processing-guide/) +Learn how to generate and save HTML results using full template processing in Aspose.HTML for Java with this detailed step-by-step guide. {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/english/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/english/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..96c2bf6d78 --- /dev/null +++ b/html/english/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,284 @@ +--- +category: general +date: 2026-07-08 +description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: en +lastmod: 2026-07-08 +og_description: Save generated HTML result quickly. This guide shows you how to load + a data source, bind it to an HTML template, process the template, and write the + output file. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Save Generated HTML Result – Step‑by‑Step Template Guide +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Save Generated HTML Result – Full Template Processing Guide +url: /java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Save Generated HTML Result – Full Template Processing Guide + +Ever wondered how to **save generated HTML result** without pulling your hair out? You’re not the only one. Whether you’re building a static site generator, an email templating engine, or just need to dump some data into a nicely formatted page, the steps are surprisingly simple once you break them down. + +In this tutorial we’ll walk through every stage—from **load data source** to **HTML template binding**, then **process template**, and finally **save generated HTML result**. By the end you’ll have a ready‑to‑run Java program that produces a populated `result.html` file in your project folder. + +## What You’ll Learn + +- How to read XML or JSON data using a tiny helper class. +- How to load an HTML file that contains `${...}`‑style placeholders. +- How the built‑in `TemplateProcessor` swaps those placeholders with real values. +- How to write the final HTML to disk so other systems can consume it. + +No external libraries, no obscure magic—just plain Java and a few intuitive classes. Grab your favorite IDE (IntelliJ, Eclipse, or even VS Code) and let’s get cracking. + +--- + +## Save Generated HTML Result – Overview + +Before we dive into code, let’s picture the whole pipeline: + +1. **Load the data source** – XML or JSON that holds the dynamic values. +2. **Load the HTML template** – a static file with data‑binding expressions. +3. **Process the template** – replace each expression with the matching data. +4. **Save the generated HTML result** – write the populated markup to a new file. + +Think of it as a simple assembly line: raw material (data) → blueprint (template) → finished product (HTML). Each stage is independent, which makes testing and debugging a breeze. + +--- + +### Step 1: Load the Data Source + +The first thing we need is a container that knows how to read either XML or JSON. In this example we’ll stick with XML because it’s easy to visualize, but swapping in JSON is just a matter of changing one class. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Why this matters:** Loading the data source early gives us a single source of truth for all placeholders. If the XML is malformed, we’ll know right away—no mystery bugs later when the template tries to bind values. + +> **Pro tip:** Keep your XML tidy and avoid deep nesting; flat structures map more cleanly to `${field}` placeholders. + +--- + +### Step 2: Load the HTML Template (HTML Template Binding) + +Next we pull in the static HTML file that contains the binding expressions. The placeholders follow the `${key}` syntax, which the processor recognises automatically. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Why we do it this way:** By keeping the original template untouched, you can reuse the same file for multiple data sets. It also makes unit‑testing the processor easier: feed it a string, verify the output, and you never have to touch the file system again. + +--- + +### Step 3: Process the Template (Process Template) + +Now comes the heart of the operation: swapping placeholders with real values. The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and injects them into the HTML string. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**What’s happening under the hood?** The processor iterates over each element in the XML document, builds a `${key}` token, and performs a simple `String.replace`. It’s not the most performant for huge files, but for typical template scenarios it’s more than enough and keeps the code readable. + +> **Edge case note:** If a placeholder appears more than once, `replace` will handle all occurrences. If a key is missing in the XML, the token stays untouched—great for spotting missing data during QA. + +--- + +### Step 4: Save Generated HTML Result + +Finally, we persist the populated markup to disk. This is where the **save generated HTML result** phrase truly shines. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Why you should care:** Writing the file is the last, decisive action. Once the HTML is on disk you can serve it with a web server, feed it to a PDF converter, or email it as a newsletter. The `save` method hides the I/O boilerplate, so your main logic stays clean and focused on the transformation. + +--- + +## Common Questions & Tips + +- **Can I use JSON instead of XML?** + Absolutely. Replace `TemplateData` with a class that parses JSON (Jackson’s `ObjectMapper` works nicely) and adjust the `process` method to read key/value pairs from a `Map`. + +- **What if my placeholders contain spaces or special characters + + +## What Should You Learn Next? + + +The following tutorials cover closely related topics that build on the techniques demonstrated in this guide. Each resource includes complete working code examples with step-by-step explanations to help you master additional API features and explore alternative implementation approaches in your own projects. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/english/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/og-image.png b/html/english/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/og-image.png new file mode 100644 index 0000000000000000000000000000000000000000..a15e505f2f8bf6cf79b19ce8bc31a71016c82e90 GIT binary patch literal 51119 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 {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/french/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/french/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..ca1340536b --- /dev/null +++ b/html/french/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,284 @@ +--- +category: general +date: 2026-07-08 +description: Enregistrez facilement le résultat HTML généré grâce à ce tutoriel étape + par étape qui vous guide à travers le chargement des données, le traitement d’un + modèle HTML et l’écriture du fichier final. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: fr +lastmod: 2026-07-08 +og_description: Enregistrez rapidement le résultat HTML généré. Ce guide vous montre + comment charger une source de données, la lier à un modèle HTML, traiter le modèle + et écrire le fichier de sortie. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Enregistrer le résultat HTML généré – Guide étape par étape du modèle +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Enregistrer le résultat HTML généré – Guide complet du traitement des modèles +url: /fr/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Enregistrer le résultat HTML généré – Guide complet de traitement de modèle + +Vous êtes-vous déjà demandé comment **enregistrer le résultat HTML généré** sans perdre patience ? Vous n'êtes pas le seul. Que vous construisiez un générateur de site statique, un moteur de modèles d'e‑mail, ou que vous ayez simplement besoin de déposer des données dans une page correctement formatée, les étapes sont étonnamment simples une fois décomposées. + +Dans ce tutoriel, nous parcourrons chaque étape — de **chargement de la source de données** à **liaison du modèle HTML**, puis **traitement du modèle**, et enfin **enregistrement du résultat HTML généré**. À la fin, vous disposerez d’un programme Java prêt à l’emploi qui produit un fichier `result.html` rempli dans le répertoire de votre projet. + +## Ce que vous allez apprendre + +- Comment lire des données XML ou JSON à l’aide d’une petite classe d’assistance. +- Comment charger un fichier HTML contenant des espaces réservés de type `${...}`. +- Comment le `TemplateProcessor` intégré remplace ces espaces réservés par de vraies valeurs. +- Comment écrire le HTML final sur le disque afin que d’autres systèmes puissent le consommer. + +Aucune bibliothèque externe, aucune magie obscure — juste du Java pur et quelques classes intuitives. Prenez votre IDE préféré (IntelliJ, Eclipse ou même VS Code) et c’est parti. + +--- + +## Enregistrer le résultat HTML généré – Vue d’ensemble + +Avant de plonger dans le code, visualisons l’ensemble du pipeline : + +1. **Charger la source de données** – XML ou JSON contenant les valeurs dynamiques. +2. **Charger le modèle HTML** – un fichier statique avec des expressions de liaison de données. +3. **Traiter le modèle** – remplacer chaque expression par la donnée correspondante. +4. **Enregistrer le résultat HTML généré** – écrire le balisage rempli dans un nouveau fichier. + +Imaginez une chaîne d’assemblage simple : matière première (données) → plan (modèle) → produit fini (HTML). Chaque étape est indépendante, ce qui facilite les tests et le débogage. + +--- + +### Étape 1 : Charger la source de données + +La première chose dont nous avons besoin est un conteneur capable de lire du XML ou du JSON. Dans cet exemple, nous restons sur le XML car il est facile à visualiser, mais remplacer par du JSON ne nécessite qu’un changement de classe. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Pourquoi c’est important :** Charger la source de données dès le départ nous donne une source unique de vérité pour tous les espaces réservés. Si le XML est mal formé, nous le saurons immédiatement—pas de bugs mystérieux plus tard lorsque le modèle tentera de lier les valeurs. + +> **Astuce :** Gardez votre XML propre et évitez les imbrications trop profondes ; les structures plates se mappent plus facilement aux espaces réservés `${field}`. + +--- + +### Étape 2 : Charger le modèle HTML (liaison du modèle HTML) + +Ensuite, nous chargeons le fichier HTML statique qui contient les expressions de liaison. Les espaces réservés utilisent la syntaxe `${key}`, reconnue automatiquement par le processeur. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Pourquoi nous procédons ainsi :** En conservant le modèle original intact, vous pouvez réutiliser le même fichier pour plusieurs jeux de données. Cela facilite également les tests unitaires du processeur : fournissez‑lui une chaîne, vérifiez la sortie, et vous n’avez plus besoin d’accéder au système de fichiers. + +--- + +### Étape 3 : Traiter le modèle (Process Template) + +Vient maintenant le cœur de l’opération : remplacer les espaces réservés par de vraies valeurs. Le `TemplateProcessor` parcourt le DOM chargé précédemment, extrait les valeurs et les injecte dans la chaîne HTML. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**Que se passe‑t‑il en coulisses ?** Le processeur itère sur chaque élément du document XML, construit un jeton `${key}` et effectue un simple `String.replace`. Ce n’est pas la solution la plus performante pour des fichiers très volumineux, mais pour les scénarios de modèles typiques c’est largement suffisant et cela garde le code lisible. + +> **Note cas limite :** Si un espace réservé apparaît plusieurs fois, `replace` traitera toutes les occurrences. Si une clé manque dans le XML, le jeton reste tel quel—ce qui est pratique pour repérer les données manquantes lors du QA. + +--- + +### Étape 4 : Enregistrer le résultat HTML généré + +Enfin, nous persistons le balisage rempli sur le disque. C’est ici que l’expression **enregistrer le résultat HTML généré** prend tout son sens. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Pourquoi c’est crucial :** L’écriture du fichier est la dernière action décisive. Une fois le HTML sur le disque, vous pouvez le servir avec un serveur web, le transmettre à un convertisseur PDF, ou l’envoyer en newsletter. La méthode `save` masque le boilerplate d’I/O, de sorte que votre logique principale reste claire et centrée sur la transformation. + +--- + +## Questions fréquentes & conseils + +- **Puis‑je utiliser JSON à la place de XML ?** + Absolument. Remplacez `TemplateData` par une classe qui analyse le JSON (l’`ObjectMapper` de Jackson fonctionne très bien) et adaptez la méthode `process` pour lire les paires clé/valeur depuis un `Map`. + +- **Que faire si mes espaces réservés contiennent des espaces ou des caractères spéciaux** + Assurez‑vous que les clés dans le XML (ou le JSON) correspondent exactement aux jetons `${...}`. Vous pouvez également pré‑traiter les clés pour remplacer les espaces par des underscores ou utiliser une convention de nommage sans caractères spéciaux. + +## Que devriez‑vous apprendre ensuite ? + + +Les tutoriels suivants couvrent des sujets étroitement liés qui s’appuient sur les techniques présentées dans ce guide. Chaque ressource comprend des exemples de code complets avec des explications pas à pas pour vous aider à maîtriser d’autres fonctionnalités d’API et à explorer des approches d’implémentation alternatives dans vos propres projets. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/german/java/saving-html-documents/_index.md b/html/german/java/saving-html-documents/_index.md index 0d7fd8faed..beac6f50a6 100644 --- a/html/german/java/saving-html-documents/_index.md +++ b/html/german/java/saving-html-documents/_index.md @@ -54,9 +54,12 @@ Konvertieren Sie HTML ganz einfach in Markdown mit Aspose.HTML für Java. Folgen Erfahren Sie in dieser Schritt-für-Schritt-Anleitung mit Codebeispielen und praktischen Tipps, wie Sie HTML-Dokumente mit Aspose.HTML für Java als MHTML speichern. ### [SVG-Dokument in Aspose.HTML für Java speichern](./save-svg-document/) Erfahren Sie mit dieser einfachen Schritt-für-Schritt-Anleitung voller Beispiele, wie Sie SVG-Dokumente mit Aspose.HTML für Java speichern. +### [Generiertes HTML-Ergebnis speichern – Vollständige Vorlagenverarbeitungsanleitung](./save-generated-html-result-full-template-processing-guide/) +Erfahren Sie, wie Sie das generierte HTML-Ergebnis mit Aspose.HTML für Java vollständig verarbeiten und speichern. + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/german/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/german/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..390de34eb0 --- /dev/null +++ b/html/german/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,282 @@ +--- +category: general +date: 2026-07-08 +description: Speichern Sie das generierte HTML-Ergebnis einfach mit dieser Schritt‑für‑Schritt‑Anleitung, + die Sie durch das Laden von Daten, die Verarbeitung einer HTML-Vorlage und das Schreiben + der finalen Datei führt. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: de +lastmod: 2026-07-08 +og_description: Speichern Sie das generierte HTML-Ergebnis schnell. Dieser Leitfaden + zeigt Ihnen, wie Sie eine Datenquelle laden, sie an ein HTML-Template binden, das + Template verarbeiten und die Ausgabedatei schreiben. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Generiertes HTML-Ergebnis speichern – Schritt‑für‑Schritt‑Vorlagenanleitung +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Generiertes HTML-Ergebnis speichern – Vollständiger Leitfaden zur Vorlagenverarbeitung +url: /de/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Speichern des generierten HTML‑Ergebnisses – Vollständige Anleitung zur Vorlagenverarbeitung + +Haben Sie sich jemals gefragt, wie man **generiertes HTML‑Ergebnis speichern** kann, ohne sich die Haare zu raufen? Sie sind nicht der Einzige. Egal, ob Sie einen static site generator, eine email templating engine bauen oder einfach Daten in eine schön formatierte Seite ausgeben müssen, die Schritte sind überraschend einfach, sobald man sie zerlegt. + +In diesem Tutorial führen wir Sie durch jede Phase – von **load data source** bis **HTML template binding**, dann **process template** und schließlich **save generated HTML result**. Am Ende haben Sie ein sofort ausführbares Java‑Programm, das eine ausgefüllte `result.html`‑Datei in Ihrem Projektordner erzeugt. + +## Was Sie lernen werden + +- Wie man XML‑ oder JSON‑Daten mit einer kleinen Hilfsklasse liest. +- Wie man eine HTML‑Datei lädt, die `${...}`‑artige Platzhalter enthält. +- Wie der integrierte `TemplateProcessor` diese Platzhalter durch echte Werte ersetzt. +- Wie man das endgültige HTML auf die Festplatte schreibt, damit andere Systeme es nutzen können. + +Keine externen Bibliotheken, keine obskure Magie – nur reines Java und ein paar intuitive Klassen. Schnappen Sie sich Ihre bevorzugte IDE (IntelliJ, Eclipse oder sogar VS Code) und legen wir los. + +--- + +## Speichern des generierten HTML‑Ergebnisses – Überblick + +Bevor wir in den Code eintauchen, stellen wir uns die gesamte Pipeline vor: + +1. **Load the data source** – XML oder JSON, das die dynamischen Werte enthält. +2. **Load the HTML template** – eine statische Datei mit data‑binding expressions. +3. **Process the template** – ersetzt jeden Ausdruck durch die passenden Daten. +4. **Save the generated HTML result** – schreibt das ausgefüllte Markup in eine neue Datei. + +Stellen Sie sich das als einfache Montagelinie vor: Rohmaterial (Daten) → Bauplan (Template) → Fertigprodukt (HTML). Jeder Schritt ist unabhängig, was das Testen und Debuggen zum Kinderspiel macht. + +--- + +### Schritt 1: Datenquelle laden + +Das Erste, was wir benötigen, ist ein Container, der entweder XML oder JSON lesen kann. In diesem Beispiel bleiben wir bei XML, weil es leicht zu visualisieren ist, aber das Austauschen gegen JSON ist nur eine Frage des Änderns einer Klasse. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Warum das wichtig ist:** Das Laden der Datenquelle zu Beginn gibt uns eine einzige Quelle der Wahrheit für alle Platzhalter. Wenn das XML fehlerhaft ist, wissen wir das sofort – keine mysteriösen Bugs später, wenn das Template versucht, Werte zu binden. + +> **Pro Tipp:** Halten Sie Ihr XML übersichtlich und vermeiden Sie tiefe Verschachtelungen; flache Strukturen lassen sich sauberer auf `${field}`‑Platzhalter abbilden. + +--- + +### Schritt 2: HTML‑Template laden (HTML Template Binding) + +Als Nächstes laden wir die statische HTML‑Datei, die die Bindungsausdrücke enthält. Die Platzhalter folgen der `${key}`‑Syntax, die der Prozessor automatisch erkennt. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Warum wir das so machen:** Indem das ursprüngliche Template unverändert bleibt, können Sie dieselbe Datei für mehrere Datensätze wiederverwenden. Es erleichtert zudem das Unit‑Testing des Prozessors: Sie geben ihm einen String, prüfen die Ausgabe, und müssen das Dateisystem nie wieder berühren. + +--- + +### Schritt 3: Template verarbeiten (Process Template) + +Jetzt kommt das Herzstück der Operation: das Ersetzen der Platzhalter durch echte Werte. Der `TemplateProcessor` durchläuft das zuvor geladene DOM, extrahiert Werte und fügt sie in den HTML‑String ein. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**Was im Hintergrund passiert:** Der Prozessor iteriert über jedes Element im XML‑Dokument, baut ein `${key}`‑Token und führt ein einfaches `String.replace` aus. Es ist nicht die performanteste Lösung für riesige Dateien, aber für typische Template‑Szenarien mehr als ausreichend und hält den Code lesbar. + +> **Hinweis zu Sonderfällen:** Wenn ein Platzhalter mehr als einmal vorkommt, übernimmt `replace` alle Vorkommen. Fehlt ein Schlüssel im XML, bleibt das Token unverändert – praktisch, um fehlende Daten während des QA‑Prozesses zu erkennen. + +--- + +### Schritt 4: Generiertes HTML‑Ergebnis speichern + +Schließlich schreiben wir das ausgefüllte Markup auf die Festplatte. Hier kommt der Ausdruck **save generated HTML result** wirklich zum Tragen. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Warum das wichtig ist:** Das Schreiben der Datei ist die letzte, entscheidende Aktion. Sobald das HTML auf der Festplatte liegt, können Sie es mit einem Webserver ausliefern, an einen PDF‑Konverter übergeben oder als Newsletter per E‑Mail verschicken. Die `save`‑Methode verbirgt das I/O‑Boilerplate, sodass Ihre Hauptlogik sauber und fokussiert auf die Transformation bleibt. + +--- + +## Häufige Fragen & Tipps + +- **Kann ich JSON anstelle von XML verwenden?** + Absolut. Ersetzen Sie `TemplateData` durch eine Klasse, die JSON parst (Jackson’s `ObjectMapper` funktioniert gut) und passen Sie die `process`‑Methode an, um Schlüssel/Wert‑Paare aus einem `Map` zu lesen. + +- **Was ist, wenn meine Platzhalter Leerzeichen oder Sonderzeichen enthalten** + +## Was sollten Sie als Nächstes lernen? + +Die folgenden Tutorials behandeln eng verwandte Themen, die auf den in diesem Leitfaden gezeigten Techniken aufbauen. Jede Ressource enthält vollständige, funktionierende Codebeispiele mit Schritt‑für‑Schritt‑Erklärungen, damit Sie zusätzliche API‑Funktionen meistern und alternative Implementierungsansätze in Ihren eigenen Projekten erkunden können. + +- [HTML‑Dokumente aus Datei laden in Aspose.HTML für Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [HTML‑Dokument speichern in Aspose.HTML für Java](/html/english/java/saving-html-documents/save-html-document/) +- [Datenverarbeitung und Stream‑Management in Aspose.HTML für Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/greek/java/saving-html-documents/_index.md b/html/greek/java/saving-html-documents/_index.md index 06e4ecfd80..9fb6c7a578 100644 --- a/html/greek/java/saving-html-documents/_index.md +++ b/html/greek/java/saving-html-documents/_index.md @@ -54,9 +54,12 @@ url: /el/java/saving-html-documents/ Μάθετε πώς να αποθηκεύετε έγγραφα HTML ως MHTML χρησιμοποιώντας το Aspose.HTML για Java με αυτόν τον οδηγό βήμα προς βήμα, που συνοδεύεται από παραδείγματα κώδικα και πρακτικές συμβουλές. ### [Αποθήκευση εγγράφου SVG στο Aspose.HTML για Java](./save-svg-document/) Μάθετε πώς να αποθηκεύετε έγγραφα SVG χρησιμοποιώντας το Aspose.HTML για Java με αυτόν τον εύκολο βήμα προς βήμα οδηγό γεμάτο με παραδείγματα. +### [Αποθήκευση παραγόμενου αποτελέσματος HTML – Οδηγός πλήρους επεξεργασίας προτύπου](./save-generated-html-result-full-template-processing-guide/) +Μάθετε πώς να αποθηκεύετε το παραγόμενο HTML αποτέλεσμα χρησιμοποιώντας πλήρη επεξεργασία προτύπου με το Aspose.HTML για Java. + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/greek/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/greek/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..c0269c8012 --- /dev/null +++ b/html/greek/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,283 @@ +--- +category: general +date: 2026-07-08 +description: Αποθηκεύστε εύκολα το παραγόμενο αποτέλεσμα HTML με αυτό το βήμα‑βήμα + οδηγό που σας καθοδηγεί στη φόρτωση δεδομένων, την επεξεργασία ενός προτύπου HTML + και τη δημιουργία του τελικού αρχείου. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: el +lastmod: 2026-07-08 +og_description: Αποθηκεύστε γρήγορα το παραγόμενο αποτέλεσμα HTML. Αυτός ο οδηγός + σας δείχνει πώς να φορτώσετε μια πηγή δεδομένων, να τη συνδέσετε με ένα πρότυπο + HTML, να επεξεργαστείτε το πρότυπο και να γράψετε το αρχείο εξόδου. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Αποθήκευση του παραγόμενου αποτελέσματος HTML – Οδηγός προτύπου βήμα‑προς‑βήμα +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Αποθήκευση του παραγόμενου αποτελέσματος HTML – Πλήρης οδηγός επεξεργασίας + προτύπων +url: /el/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Αποθήκευση Παραγόμενου HTML Αποτελέσματος – Οδηγός Πλήρους Επεξεργασίας Προτύπου + +Έχετε αναρωτηθεί ποτέ πώς να **αποθηκεύσετε το παραγόμενο αποτέλεσμα HTML** χωρίς να τσακίζετε τα μαλλιά σας; Δεν είστε ο μόνος. Είτε δημιουργείτε έναν στατικό γεννήτρια ιστοσελίδων, μια μηχανή προτύπων email, είτε απλώς χρειάζεστε να αποτυπώσετε κάποια δεδομένα σε μια καλοσχεδιασμένη σελίδα, τα βήματα είναι εκπληκτικά απλά μόλις τα αναλύσετε. + +Σε αυτό το tutorial θα περάσουμε από κάθε στάδιο — από **load data source** μέχρι **HTML template binding**, στη συνέχεια **process template**, και τέλος **save generated HTML result**. Στο τέλος θα έχετε ένα έτοιμο‑για‑εκτέλεση πρόγραμμα Java που παράγει ένα γεμάτο αρχείο `result.html` στον φάκελο του έργου σας. + +## Τι Θα Μάθετε + +- Πώς να διαβάσετε δεδομένα XML ή JSON χρησιμοποιώντας μια μικρή βοηθητική κλάση. +- Πώς να φορτώσετε ένα αρχείο HTML που περιέχει placeholders σε μορφή `${...}`. +- Πώς ο ενσωματωμένος `TemplateProcessor` αντικαθιστά αυτά τα placeholders με πραγματικές τιμές. +- Πώς να γράψετε το τελικό HTML στο δίσκο ώστε άλλα συστήματα να το καταναλώνουν. + +Χωρίς εξωτερικές βιβλιοθήκες, χωρίς ακατανόητη μαγεία — μόνο καθαρή Java και μερικές διαισθητικές κλάσεις. Πάρτε το αγαπημένο σας IDE (IntelliJ, Eclipse ή ακόμη και VS Code) και ας ξεκινήσουμε. + +--- + +## Αποθήκευση Παραγόμενου HTML Αποτελέσματος – Επισκόπηση + +Πριν βουτήξουμε στον κώδικα, ας φανταστούμε ολόκληρη τη ροή εργασίας: + +1. **Load the data source** – XML ή JSON που περιέχει τις δυναμικές τιμές. +2. **Load the HTML template** – ένα στατικό αρχείο με εκφράσεις δέσμευσης δεδομένων. +3. **Process the template** – αντικαθιστά κάθε έκφραση με τα αντίστοιχα δεδομένα. +4. **Save the generated HTML result** – γράφει το γεμάτο markup σε ένα νέο αρχείο. + +Σκεφτείτε το ως μια απλή γραμμή συναρμολόγησης: πρώτες ύλες (δεδομένα) → σχέδιο (πρότυπο) → τελικό προϊόν (HTML). Κάθε στάδιο είναι ανεξάρτητο, κάτι που κάνει τη δοκιμή και την αποσφαλμάτωση παιχνιδάκι. + +--- + +### Βήμα 1: Φόρτωση Πηγής Δεδομένων + +Το πρώτο που χρειαζόμαστε είναι ένα κοντέινερ που ξέρει πώς να διαβάσει είτε XML είτε JSON. Σε αυτό το παράδειγμα θα παραμείνουμε στο XML επειδή είναι εύκολο να το οπτικοποιήσουμε, αλλά η εναλλαγή σε JSON είναι απλώς θέμα αλλαγής μιας κλάσης. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Γιατί είναι σημαντικό:** Η φόρτωση της πηγής δεδομένων νωρίς μας παρέχει μια ενιαία πηγή αλήθειας για όλα τα placeholders. Αν το XML είναι κακοδιατυπωμένο, θα το γνωρίζουμε αμέσως — χωρίς μυστήρια σφάλματα αργότερα όταν το πρότυπο προσπαθήσει να δεσμεύσει τιμές. + +> **Pro tip:** Διατηρήστε το XML σας τακτοποιημένο και αποφύγετε το βαθύ εμφώλευση· οι επίπεδες δομές αντιστοιχούν πιο καθαρά σε placeholders `${field}`. + +--- + +### Βήμα 2: Φόρτωση του HTML Προτύπου (HTML Template Binding) + +Στη συνέχεια φέρνουμε το στατικό αρχείο HTML που περιέχει τις εκφράσεις δέσμευσης. Τα placeholders ακολουθούν τη σύνταξη `${key}`, την οποία ο επεξεργαστής αναγνωρίζει αυτόματα. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Γιατί το κάνουμε έτσι:** Διατηρώντας το αρχικό πρότυπο αμετάβλητο, μπορείτε να επαναχρησιμοποιήσετε το ίδιο αρχείο για πολλαπλά σύνολα δεδομένων. Επίσης, κάνει τη μονάδα‑testing του επεξεργαστή πιο εύκολη: τροφοδοτήστε το με μια συμβολοσειρά, επαληθεύστε το αποτέλεσμα, και δεν χρειάζεται ποτέ ξανά να αγγίξετε το σύστημα αρχείων. + +--- + +### Βήμα 3: Επεξεργασία του Προτύπου (Process Template) + +Τώρα έρχεται η καρδιά της λειτουργίας: η αντικατάσταση των placeholders με πραγματικές τιμές. Ο `TemplateProcessor` διασχίζει το DOM που φορτώσαμε νωρίτερα, εξάγει τιμές και τις ενσωματώνει στη συμβολοσειρά HTML. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**Τι συμβαίνει στο παρασκήνιο;** Ο επεξεργαστής επαναλαμβάνει κάθε στοιχείο στο έγγραφο XML, δημιουργεί ένα token `${key}` και εκτελεί ένα απλό `String.replace`. Δεν είναι η πιο αποδοτική λύση για τεράστια αρχεία, αλλά για τυπικά σενάρια προτύπων είναι περισσότερο από αρκετό και διατηρεί τον κώδικα ευανάγνωστο. + +> **Edge case note:** Αν ένα placeholder εμφανίζεται περισσότερες από μία φορές, το `replace` θα διαχειριστεί όλες τις εμφανίσεις. Αν ένα κλειδί λείπει στο XML, το token παραμένει αμετάβλητο — ιδανικό για εντοπισμό ελλιπών δεδομένων κατά τη QA. + +--- + +### Βήμα 4: Αποθήκευση Παραγόμενου HTML Αποτελέσματος + +Τέλος, αποθηκεύουμε το γεμάτο markup στο δίσκο. Εδώ η φράση **save generated HTML result** λάμπει πραγματικά. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Γιατί να σας ενδιαφέρει:** Η εγγραφή του αρχείου είναι η τελευταία, αποφασιστική ενέργεια. Μόλις το HTML είναι στο δίσκο, μπορείτε να το σερβίρετε με έναν web server, να το δώσετε σε μετατροπέα PDF, ή να το στείλετε ως newsletter. Η μέθοδος `save` κρύβει το boilerplate I/O, ώστε η κύρια λογική σας να παραμένει καθαρή και εστιασμένη στη μετατροπή. + +--- + +## Συχνές Ερωτήσεις & Συμβουλές + +- **Μπορώ να χρησιμοποιήσω JSON αντί για XML;** + Απόλυτα. Αντικαταστήστε το `TemplateData` με μια κλάση που αναλύει JSON (ο `ObjectMapper` του Jackson λειτουργεί καλά) και προσαρμόστε τη μέθοδο `process` ώστε να διαβάζει ζεύγη κλειδί/τιμή από ένα `Map`. + +- **Τι γίνεται αν τα placeholders μου περιέχουν κενά ή ειδικούς χαρακτήρες + +## Τι Θα Πρέπει Να Μάθετε Στη Σειρά; + +Τα παρακάτω tutorials καλύπτουν στενά συναφή θέματα που βασίζονται στις τεχνικές που παρουσιάστηκαν σε αυτόν τον οδηγό. Κάθε πόρος περιλαμβάνει πλήρη λειτουργικά παραδείγματα κώδικα με βήμα‑βήμα εξηγήσεις για να σας βοηθήσουν να κυριαρχήσετε σε πρόσθετες δυνατότητες API και να εξερευνήσετε εναλλακτικές προσεγγίσεις υλοποίησης στα δικά σας έργα. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/hindi/java/saving-html-documents/_index.md b/html/hindi/java/saving-html-documents/_index.md index 5f57e5073d..a5ac6678bc 100644 --- a/html/hindi/java/saving-html-documents/_index.md +++ b/html/hindi/java/saving-html-documents/_index.md @@ -51,12 +51,15 @@ Java के लिए Aspose.HTML का उपयोग करके HTML द ### [Java के लिए Aspose.HTML में HTML को Markdown में बदलें](./convert-html-to-markdown/) Java के लिए Aspose.HTML का उपयोग करके HTML को आसानी से Markdown में बदलें। सहज सामग्री रूपांतरण और हेरफेर के लिए इस चरण-दर-चरण मार्गदर्शिका का पालन करें। ### [Java के लिए Aspose.HTML में HTML को MHTML में सहेजें](./save-html-to-mhtml/) -इस चरण-दर-चरण मार्गदर्शिका के साथ, कोड उदाहरणों और व्यावहारिक युक्तियों के साथ, Java के लिए Aspose.HTML का उपयोग करके HTML दस्तावेज़ों को MHTML के रूप में सहेजना सीखें। +इस चरण-दर-स्टेप मार्गदर्शिका के साथ, कोड उदाहरणों और व्यावहारिक युक्तियों के साथ, Java के लिए Aspose.HTML का उपयोग करके HTML दस्तावेज़ों को MHTML के रूप में सहेजना सीखें। ### [Java के लिए Aspose.HTML में SVG दस्तावेज़ सहेजें](./save-svg-document/) उदाहरणों से भरपूर इस आसान चरण-दर-चरण मार्गदर्शिका के साथ Java के लिए Aspose.HTML का उपयोग करके SVG दस्तावेज़ों को सहेजना सीखें। +### [Java के लिए Aspose.HTML में उत्पन्न HTML परिणाम सहेजें – पूर्ण टेम्पलेट प्रोसेसिंग गाइड](./save-generated-html-result-full-template-processing-guide/) +Java के लिए Aspose.HTML का उपयोग करके पूर्ण टेम्पलेट प्रोसेसिंग के साथ उत्पन्न HTML परिणाम को सहेजने का चरण-दर-चरण मार्गदर्शन। + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/hindi/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/hindi/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..f4cb9fe741 --- /dev/null +++ b/html/hindi/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,272 @@ +--- +category: general +date: 2026-07-08 +description: इस चरण‑दर‑चरण ट्यूटोरियल के साथ उत्पन्न HTML परिणाम को आसानी से सहेजें, + जो आपको डेटा लोड करने, HTML टेम्पलेट प्रोसेस करने और अंतिम फ़ाइल लिखने के माध्यम + से मार्गदर्शन करता है। +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: hi +lastmod: 2026-07-08 +og_description: जनरेट किए गए HTML परिणाम को जल्दी सहेजें। यह गाइड आपको दिखाता है कि + डेटा स्रोत को कैसे लोड करें, उसे HTML टेम्पलेट से बाइंड करें, टेम्पलेट को प्रोसेस + करें, और आउटपुट फ़ाइल लिखें। +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: जनरेट किया गया HTML परिणाम सहेजें – चरण‑दर‑चरण टेम्प्लेट गाइड +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: जनरेटेड HTML परिणाम सहेजें – पूर्ण टेम्पलेट प्रोसेसिंग गाइड +url: /hi/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# जनरेटेड HTML परिणाम सहेजें – पूर्ण टेम्पलेट प्रोसेसिंग गाइड + +क्या आपने कभी सोचा है कि **जनरेटेड HTML परिणाम सहेजें** बिना सिरदर्द के कैसे किया जाए? आप अकेले नहीं हैं। चाहे आप एक स्थैतिक साइट जेनरेटर, एक ईमेल टेम्पलेटिंग इंजन बना रहे हों, या बस कुछ डेटा को एक सुंदर फ़ॉर्मेटेड पेज में डालना चाहते हों, चरणों को तोड़ने के बाद यह आश्चर्यजनक रूप से सरल है। + +इस ट्यूटोरियल में हम हर चरण को विस्तार से देखेंगे—**डेटा स्रोत लोड करना** से लेकर **HTML टेम्पलेट बाइंडिंग**, फिर **टेम्पलेट प्रोसेस करना**, और अंत में **जनरेटेड HTML परिणाम सहेजना**। अंत तक आपके पास एक तैयार‑चलाने‑योग्य Java प्रोग्राम होगा जो आपके प्रोजेक्ट फ़ोल्डर में एक भरा हुआ `result.html` फ़ाइल बनाता है। + +## आप क्या सीखेंगे + +- एक छोटे हेल्पर क्लास का उपयोग करके XML या JSON डेटा पढ़ना। +- `${...}`‑स्टाइल प्लेसहोल्डर वाले HTML फ़ाइल को लोड करना। +- बिल्ट‑इन `TemplateProcessor` कैसे उन प्लेसहोल्डरों को वास्तविक मानों से बदलता है। +- अंतिम HTML को डिस्क पर लिखना ताकि अन्य सिस्टम इसे उपयोग कर सकें। + +कोई बाहरी लाइब्रेरी नहीं, कोई रहस्यमय जादू नहीं—सिर्फ साधारण Java और कुछ सहज क्लासेज़। अपना पसंदीदा IDE (IntelliJ, Eclipse, या यहाँ तक कि VS Code) खोलें और चलिए शुरू करते हैं। + +--- + +## जनरेटेड HTML परिणाम सहेजें – अवलोकन + +कोड में डुबकी लगाने से पहले, पूरे पाइपलाइन की कल्पना करें: + +1. **डेटा स्रोत लोड करें** – वह XML या JSON जिसमें डायनामिक वैल्यूज़ हों। +2. **HTML टेम्पलेट लोड करें** – डेटा‑बाइंडिंग एक्सप्रेशन्स वाली स्थैतिक फ़ाइल। +3. **टेम्पलेट प्रोसेस करें** – प्रत्येक एक्सप्रेशन को मिलते‑जुलते डेटा से बदलें। +4. **जनरेटेड HTML परिणाम सहेजें** – भरे हुए मार्कअप को नई फ़ाइल में लिखें। + +इसे एक सरल असेंबली लाइन की तरह सोचें: कच्चा माल (डेटा) → ब्लूप्रिंट (टेम्पलेट) → तैयार उत्पाद (HTML)। प्रत्येक चरण स्वतंत्र है, जिससे टेस्टिंग और डिबगिंग आसान हो जाता है। + +### चरण 1: डेटा स्रोत लोड करें + +सबसे पहले हमें एक कंटेनर चाहिए जो XML या JSON दोनों पढ़ सके। इस उदाहरण में हम XML का उपयोग करेंगे क्योंकि इसे देखना आसान है, लेकिन JSON में बदलना सिर्फ एक क्लास बदलने का मामला है। + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Why this matters:** डेटा स्रोत को पहले लोड करने से सभी प्लेसहोल्डरों के लिए एक ही सत्य स्रोत मिल जाता है। यदि XML खराब फ़ॉर्मेटेड है, तो हमें तुरंत पता चल जाएगा—बाद में टेम्पलेट बाइंडिंग के समय रहस्यमयी बग नहीं आएंगे। + +> **Pro tip:** अपना XML साफ‑सुथरा रखें और गहरी नेस्टिंग से बचें; फ्लैट स्ट्रक्चर `${field}` प्लेसहोल्डरों के साथ अधिक सहजता से मैप होते हैं। + +### चरण 2: HTML टेम्पलेट लोड करें (HTML टेम्पलेट बाइंडिंग) + +अब हम उस स्थैतिक HTML फ़ाइल को लाते हैं जिसमें बाइंडिंग एक्सप्रेशन्स होते हैं। प्लेसहोल्डर `${key}` सिंटैक्स का पालन करते हैं, जिसे प्रोसेसर स्वचालित रूप से पहचानता है। + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Why we do it this way:** मूल टेम्पलेट को अपरिवर्तित रखकर, आप वही फ़ाइल कई डेटा सेटों के लिए पुनः उपयोग कर सकते हैं। यह प्रोसेसर की यूनिट‑टेस्टिंग को भी आसान बनाता है: उसे एक स्ट्रिंग दें, आउटपुट वेरिफ़ाई करें, और आपको फिर फ़ाइल सिस्टम को छूने की ज़रूरत नहीं पड़ेगी। + +### चरण 3: टेम्पलेट प्रोसेस करें (Process Template) + +अब ऑपरेशन का दिल आता है: प्लेसहोल्डरों को वास्तविक मानों से बदलना। `TemplateProcessor` पहले लोड किए गए DOM पर चलता है, मान निकालता है, और उन्हें HTML स्ट्रिंग में इन्जेक्ट करता है। + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**What’s happening under the hood?** प्रोसेसर XML दस्तावेज़ के प्रत्येक एलिमेंट पर इटररेट करता है, `${key}` टोकन बनाता है, और एक साधारण `String.replace` करता है। यह बड़े फ़ाइलों के लिए सबसे तेज़ नहीं है, लेकिन सामान्य टेम्पलेट परिदृश्यों में यह पर्याप्त है और कोड को पढ़ने योग्य रखता है। + +> **Edge case note:** यदि कोई प्लेसहोल्डर एक से अधिक बार आता है, `replace` सभी occurrences को संभाल लेगा। यदि XML में कोई कुंजी गायब है, तो टोकन अपरिवर्तित रहेगा—QA के दौरान गायब डेटा को पहचानने में यह मददगार है। + +### चरण 4: जनरेटेड HTML परिणाम सहेजें + +अंत में, हम भरे हुए मार्कअप को डिस्क पर सहेजते हैं। यही वह जगह है जहाँ **save generated HTML result** वाक्यांश वास्तव में चमकता है। + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Why you should care:** फ़ाइल लिखना अंतिम, निर्णायक कदम है। एक बार HTML डिस्क पर हो जाने के बाद आप इसे वेब सर्वर से सर्व कर सकते हैं, PDF कन्वर्टर को फीड कर सकते हैं, या न्यूज़लेटर के रूप में ईमेल कर सकते हैं। `save` मेथड I/O बायलरप्लेट को छुपा देता है, जिससे आपका मुख्य लॉजिक साफ़ और ट्रांसफ़ॉर्मेशन पर केंद्रित रहता है। + +## सामान्य प्रश्न और टिप्स + +- **क्या मैं XML की जगह JSON इस्तेमाल कर सकता हूँ?** + बिल्कुल। `TemplateData` को एक ऐसी क्लास से बदलें जो JSON पार्स करे (Jackson का `ObjectMapper` अच्छी तरह काम करता है) और `process` मेथड को `Map` से की/वैल्यू पेयर्स पढ़ने के लिए समायोजित करें। + +- **यदि मेरे प्लेसहोल्डर में स्पेस या विशेष अक्षर हों** + +## आपको आगे क्या सीखना चाहिए? + +निम्नलिखित ट्यूटोरियल्स उन विषयों को कवर करते हैं जो इस गाइड में दिखाए गए तकनीकों पर आधारित हैं। प्रत्येक संसाधन में पूर्ण कार्यशील कोड उदाहरण और चरण‑दर‑चरण व्याख्याएँ शामिल हैं, जिससे आप अतिरिक्त API फीचर्स में महारत हासिल कर सकें और अपने प्रोजेक्ट्स में वैकल्पिक इम्प्लीमेंटेशन अप्रोच को एक्सप्लोर कर सकें। + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/hongkong/java/saving-html-documents/_index.md b/html/hongkong/java/saving-html-documents/_index.md index 16ba930b2e..1151172392 100644 --- a/html/hongkong/java/saving-html-documents/_index.md +++ b/html/hongkong/java/saving-html-documents/_index.md @@ -54,9 +54,12 @@ url: /zh-hant/java/saving-html-documents/ 透過本逐步指南（包含程式碼範例和實用技巧），了解如何使用 Aspose.HTML for Java 將 HTML 文件儲存為 MHTML。 ### [在 Aspose.HTML for Java 中儲存 SVG 文檔](./save-svg-document/) 透過這個包含範例的簡單逐步指南，了解如何使用 Aspose.HTML for Java 儲存 SVG 文件。 +### [在 Aspose.HTML for Java 中儲存產生的 HTML 結果 – 完整範本處理指南](./save-generated-html-result-full-template-processing-guide/) +本指南說明如何使用 Aspose.HTML for Java 生成完整的 HTML 範本並將結果儲存至檔案。 + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/hongkong/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/hongkong/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..683700165e --- /dev/null +++ b/html/hongkong/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,278 @@ +--- +category: general +date: 2026-07-08 +description: 透過此一步一步的教學，輕鬆儲存產生的 HTML 結果，教您如何載入資料、處理 HTML 模板，並寫入最終檔案。 +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: zh-hant +lastmod: 2026-07-08 +og_description: 快速儲存產生的 HTML 結果。本指南說明如何載入資料來源、將其綁定至 HTML 範本、處理該範本，並寫入輸出檔案。 +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: 儲存產出 HTML 結果 – 步驟式範本指南 +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: 儲存產生的 HTML 結果 – 完整模板處理指南 +url: /zh-hant/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# 儲存產生的 HTML 結果 – 完整範本處理指南 + +有沒有想過如何 **save generated HTML result** 而不至於抓狂？你並不是唯一有此困擾的人。無論你是在構建靜態網站生成器、電子郵件範本引擎，或只是需要把一些資料匯出到格式整齊的頁面，當你把步驟拆開來看時，會發現其實相當簡單。 + +在本教學中，我們將逐步說明每個階段——從 **load data source** 到 **HTML template binding**，再到 **process template**，最後 **save generated HTML result**。完成後，你將擁有一個可直接執行的 Java 程式，會在專案資料夾產生填入資料的 `result.html` 檔案。 + +## 你將學到 + +- 如何使用小型輔助類別讀取 XML 或 JSON 資料。 +- 如何載入包含 `${...}` 風格佔位符的 HTML 檔案。 +- 內建的 `TemplateProcessor` 如何將這些佔位符替換為真實值。 +- 如何將最終的 HTML 寫入磁碟，讓其他系統可以使用。 + +不需要外部函式庫，也不需要神祕的魔法——只要純粹的 Java 加上幾個直觀的類別。打開你最喜歡的 IDE（IntelliJ、Eclipse，甚至 VS Code），讓我們開始吧。 + +--- + +## 儲存產生的 HTML 結果 – 概觀 + +在深入程式碼之前，先來想像整個流程： + +1. **Load the data source** – 包含動態值的 XML 或 JSON。 +2. **Load the HTML template** – 含有資料綁定表達式的靜態檔案。 +3. **Process the template** – 用相對應的資料取代每個表達式。 +4. **Save the generated HTML result** – 將填入資料的標記寫入新檔案。 + +把它想像成簡單的組裝線：原料（資料）→ 藍圖（範本）→ 成品（HTML）。每個階段都是獨立的，讓測試與除錯變得輕而易舉。 + +--- + +### 步驟 1：載入資料來源 + +我們首先需要一個能讀取 XML 或 JSON 的容器。在此範例中，我們會使用 XML，因為它較易於觀察，但改成 JSON 只需要換掉一個類別而已。 + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Why this matters:** 早期載入資料來源可為所有佔位符提供唯一的真實來源。如果 XML 格式錯誤，我們會立即發現——不會在範本嘗試綁定值時才出現難以追蹤的錯誤。 + +> **Pro tip:** 保持 XML 整潔，避免過深的巢狀結構；平坦的結構較能直接對應 `${field}` 佔位符。 + +--- + +### 步驟 2：載入 HTML 範本（HTML Template Binding） + +接著我們載入包含綁定表達式的靜態 HTML 檔案。佔位符遵循 `${key}` 語法，處理器會自動辨識。 + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Why we do it this way:** 保持原始範本不被修改，你可以將同一檔案重複使用於不同資料集。這也讓單元測試處理器變得更簡單：提供一段字串、驗證輸出，之後就不必再觸碰檔案系統。 + +--- + +### 步驟 3：處理範本（Process Template） + +現在進入操作的核心：將佔位符替換為真實值。`TemplateProcessor` 會遍歷先前載入的 DOM，提取值並注入到 HTML 字串中。 + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**What’s happening under the hood?** 處理器會遍歷 XML 文件中的每個元素，組成 `${key}` 代碼，並執行簡單的 `String.replace`。對於大型檔案而言效能不是最佳，但在一般範本情境下已足夠，且程式碼易於閱讀。 + +> **Edge case note:** 若佔位符出現多次，`replace` 會處理所有出現的情況。若 XML 中缺少某個鍵，代碼將保持未變——這對於在 QA 時發現遺漏資料非常有幫助。 + +--- + +### 步驟 4：儲存產生的 HTML 結果 + +最後，我們將填入資料的標記寫入磁碟。這正是 **save generated HTML result** 真正發光發熱的地方。 + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Why you should care:** 寫入檔案是最後且關鍵的步驟。HTML 一旦寫入磁碟，你就可以透過網頁伺服器提供、送給 PDF 轉換器，或作為電子報寄送。`save` 方法隱藏了 I/O 的樣板程式碼，讓主要邏輯保持簡潔，專注於轉換本身。 + +--- + +## 常見問題與技巧 + +- **Can I use JSON instead of XML?** + 當然可以。將 `TemplateData` 換成能解析 JSON 的類別（Jackson 的 `ObjectMapper` 表現不錯），並調整 `process` 方法，改為從 `Map` 讀取鍵/值對。 + +- **如果我的佔位符包含空格或特殊字元，該怎麼辦** + +## 接下來該學什麼？ + +以下教學涵蓋與本指南密切相關的主題，並以此為基礎延伸技巧。每個資源都提供完整可執行的程式碼範例與逐步說明，協助你精通更多 API 功能，並在自己的專案中探索其他實作方式。 + +- [在 Aspose.HTML for Java 中從檔案載入 HTML 文件](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [在 Aspose.HTML for Java 中儲存 HTML 文件](/html/english/java/saving-html-documents/save-html-document/) +- [在 Aspose.HTML for Java 中的資料處理與串流管理](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/hungarian/java/saving-html-documents/_index.md b/html/hungarian/java/saving-html-documents/_index.md index 4afe8a7347..f930cdcd7d 100644 --- a/html/hungarian/java/saving-html-documents/_index.md +++ b/html/hungarian/java/saving-html-documents/_index.md @@ -49,14 +49,16 @@ Tanulja meg, hogyan menthet HTML-dokumentumokat az Aspose.HTML for Java használ ### [Mentse a HTML-dokumentumot fájlba az Aspose.HTML for Java-ban](./save-html-to-file/) Ismerje meg, hogyan menthet HTML-dokumentumot fájlba az Aspose.HTML for Java használatával, amely tökéletes több összekapcsolt erőforrás egyszerű kezeléséhez. ### [Konvertálja a HTML-t Markdown-ra az Aspose.HTML for Java-ban](./convert-html-to-markdown/) -Könnyen konvertálhatja a HTML-t Markdown-ba az Aspose.HTML for Java segítségével. Kövesse ezt a lépésenkénti útmutatót a tartalom zökkenőmentes átalakításához és manipulálásához. +Könnyen konvertálhatja a HTML-t Markdown-ba az Aspose.HTML for Java segítségével. Kövesse ezt a lépésről lépésre útmutatót a tartalom zökkenőmentes átalakításához és manipulálásához. ### [Mentse a HTML-t MHTML-be az Aspose.HTML for Java-ban](./save-html-to-mhtml/) Ebből a lépésről-lépésre kódpéldákkal és gyakorlati tippekkel kiegészített útmutatóból megtudhatja, hogyan menthet HTML-dokumentumokat MHTML-ként az Aspose.HTML for Java használatával. ### [Mentse az SVG-dokumentumot az Aspose.HTML for Java-ba](./save-svg-document/) Ebből az egyszerű, példákat tartalmazó útmutatóból megtudhatja, hogyan menthet SVG-dokumentumokat az Aspose.HTML for Java használatával. +### [Generált HTML eredmény mentése – Teljes sablonfeldolgozási útmutató](./save-generated-html-result-full-template-processing-guide/) +Ismerje meg, hogyan menthet generált HTML eredményeket, és használhatja a teljes sablonfeldolgozási útmutatót az Aspose.HTML for Java-ban. {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/hungarian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/hungarian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..606c66e9ca --- /dev/null +++ b/html/hungarian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,285 @@ +--- +category: general +date: 2026-07-08 +description: Mentse el egyszerűen a generált HTML eredményt ezzel a lépésről‑lépésre + útmutatóval, amely végigvezet az adatok betöltésén, a HTML sablon feldolgozásán + és a végső fájl írásán. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: hu +lastmod: 2026-07-08 +og_description: Mentse gyorsan a generált HTML eredményt. Ez az útmutató megmutatja, + hogyan töltsön be egy adatforrást, kössön azt egy HTML sablonhoz, dolgozza fel a + sablont, és írja ki a kimeneti fájlt. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Generált HTML eredmény mentése – Lépésről lépésre sablon útmutató +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Generált HTML eredmény mentése – Teljes sablonfeldolgozási útmutató +url: /hu/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Generált HTML eredmény mentése – Teljes sablonfeldolgozási útmutató + +Gondolkodtál már azon, hogyan **mentheted el a generált HTML eredményt** anélkül, hogy a hajadba nyúlnál? Nem vagy egyedül. Akár statikus weboldalgenerátort építesz, akár e‑mail sablonmotort, vagy csak adatot szeretnél szép formázott oldalra kiírni, a lépések meglepően egyszerűek, ha lebontod őket. + +Ebben a tutorialban végigvezetünk minden szakaszon – a **adatforrás betöltésétől** a **HTML sablon kötéséig**, majd a **sablon feldolgozásáig**, végül a **generált HTML eredmény mentéséig**. A végére egy kész‑Java programod lesz, amely egy `result.html` fájlt hoz létre a projekt könyvtárában. + +## Mit fogsz megtanulni + +- Hogyan olvass XML vagy JSON adatokat egy apró segédosztály segítségével. +- Hogyan tölts be egy HTML fájlt, amely `${...}`‑stílusú helyőrzőket tartalmaz. +- Hogyan cseréli ki a beépített `TemplateProcessor` ezeket a helyőrzőket a valós értékekre. +- Hogyan írjuk a végleges HTML‑t lemezre, hogy más rendszerek felhasználhassák. + +Nincs külső könyvtár, nincs rejtett varázslat – csak tiszta Java és néhány intuitív osztály. Vedd elő a kedvenc IDE‑det (IntelliJ, Eclipse vagy akár VS Code) és kezdjünk bele. + +--- + +## Generált HTML eredmény mentése – Áttekintés + +Mielőtt a kódba merülnénk, nézzük meg a teljes folyamatot: + +1. **Az adatforrás betöltése** – XML vagy JSON, amely a dinamikus értékeket tartalmazza. +2. **A HTML sablon betöltése** – egy statikus fájl adat‑kötési kifejezésekkel. +3. **A sablon feldolgozása** – minden kifejezést a megfelelő adatra cserél. +4. **A generált HTML eredmény mentése** – a kitöltött markupot egy új fájlba írja. + +Gondolj rá úgy, mint egy egyszerű összeszerelő vonatra: nyers anyag (adat) → tervrajz (sablon) → kész termék (HTML). Minden szakasz önálló, ami megkönnyíti a tesztelést és a hibakeresést. + +--- + +### 1. lépés: Az adatforrás betöltése + +Az első dolog, amire szükségünk van, egy tároló, amely képes XML‑t vagy JSON‑t beolvasni. Ebben a példában az XML‑et használjuk, mert könnyen áttekinthető, de a JSON‑ra való váltás csak egy osztály módosítását igényli. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Miért fontos:** Az adatforrás korai betöltése egyetlen igazságforrást biztosít minden helyőrzőhöz. Ha az XML hibás, azonnal tudni fogjuk – nem lesznek rejtett hibák később, amikor a sablon megpróbálja kötni az értékeket. + +> **Pro tip:** Tartsd rendezettnek az XML‑t, és kerüld a mély beágyazást; az egyszerű struktúrák tisztábban leképezhetők a `${field}` helyőrzőkre. + +--- + +### 2. lépés: A HTML sablon betöltése (HTML Template Binding) + +Ezután betöltjük a statikus HTML fájlt, amely a kötési kifejezéseket tartalmazza. A helyőrzők a `${key}` szintaxist követik, amelyet a processzor automatikusan felismer. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Miért így csináljuk:** Az eredeti sablon érintetlenül hagyásával ugyanazt a fájlt újra‑újra felhasználhatod különböző adatcsoportokhoz. Emellett megkönnyíti a processzor unit‑tesztelését: adj neki egy stringet, ellenőrizd a kimenetet, és már nem kell a fájlrendszert érintened. + +--- + +### 3. lépés: A sablon feldolgozása (Process Template) + +Most jön a művelet szíve: a helyőrzők cseréje valós értékekre. A `TemplateProcessor` bejárja a korábban betöltött DOM‑ot, kinyeri az értékeket, és beilleszti őket a HTML stringbe. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**Mi történik a háttérben?** A processzor végigiterál az XML dokumentum minden elemén, egy `${key}` token‑t épít, és egyszerű `String.replace`‑et hajt végre. Nem a leggyorsabb megoldás hatalmas fájlok esetén, de a tipikus sablon‑szcenáriókhoz bőven elegendő, és a kód olvasható marad. + +> **Edge case note:** Ha egy helyőrző több alkalommal is előfordul, a `replace` az összes előfordulást kezeli. Ha egy kulcs hiányzik az XML‑ből, a token érintetlen marad – ez nagyszerű a hiányzó adatok QA‑s során történő felismeréséhez. + +--- + +### 4. lépés: Generált HTML eredmény mentése + +Végül a kitöltött markupot lemezre írjuk. Itt jönnek igazán a **save generated HTML result** szavak jelentőségére. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Miért fontos:** A fájl írása az utolsó, döntő lépés. Amint a HTML a lemezen van, kiszolgálhatod egy webszerverrel, átadhatod egy PDF‑konvertálónak, vagy hírlevélként elküldheted. A `save` metódus elrejti az I/O boilerplate‑t, így a fő logikád tiszta és a transzformációra fókuszál. + +--- + +## Gyakori kérdések és tippek + +- **Használhatok JSON‑t XML helyett?** + Természetesen. Cseréld le a `TemplateData`‑t egy olyan osztályra, amely JSON‑t parse‑ol (a Jackson `ObjectMapper` jól működik), és módosítsd a `process` metódust, hogy egy `Map`‑ből olvassa a kulcs/érték párokat. + +- **Mi van, ha a helyőrzők szóközöket vagy speciális karaktereket tartalmaznak?** + Ügyelj arra, hogy a kulcsok ne tartalmazzanak whitespace‑et vagy olyan karaktereket, amelyeket a `String.replace` nem kezel megfelelően. Ha szükséges, előzetesen escape‑eld vagy normalizáld a kulcsokat. + +--- + +## Mit érdemes még megtanulni? + +A következő tutorialok szorosan kapcsolódó témákat fednek le, amelyek tovább építik a jelen útmutatóban bemutatott technikákat. Minden forrás komplett, működő kódpéldákat és lépésről‑lépésre magyarázatokat tartalmaz, hogy elsajátíthasd az API további funkcióit és alternatív megvalósítási megközelítéseket a saját projektjeidben. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/indonesian/java/saving-html-documents/_index.md b/html/indonesian/java/saving-html-documents/_index.md index 4b2c5d6fa6..e68fe30c58 100644 --- a/html/indonesian/java/saving-html-documents/_index.md +++ b/html/indonesian/java/saving-html-documents/_index.md @@ -54,9 +54,12 @@ Ubah HTML menjadi Markdown dengan mudah menggunakan Aspose.HTML untuk Java. Ikut Pelajari cara menyimpan dokumen HTML sebagai MHTML menggunakan Aspose.HTML untuk Java dengan panduan langkah demi langkah ini, lengkap dengan contoh kode dan kiat praktis. ### [Simpan Dokumen SVG di Aspose.HTML untuk Java](./save-svg-document/) Pelajari cara menyimpan dokumen SVG menggunakan Aspose.HTML untuk Java dengan panduan langkah demi langkah mudah yang dilengkapi dengan contoh. +### [Simpan Hasil HTML yang Dihasilkan – Panduan Pemrosesan Template Lengkap](./save-generated-html-result-full-template-processing-guide/) +Pelajari cara menyimpan hasil HTML yang dihasilkan dengan pemrosesan template lengkap menggunakan Aspose.HTML untuk Java. + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/indonesian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/indonesian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..1ec424cfc6 --- /dev/null +++ b/html/indonesian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,284 @@ +--- +category: general +date: 2026-07-08 +description: Simpan hasil HTML yang dihasilkan dengan mudah menggunakan tutorial langkah + demi langkah ini yang memandu Anda melalui proses memuat data, memproses template + HTML, dan menulis file akhir. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: id +lastmod: 2026-07-08 +og_description: Simpan hasil HTML yang dihasilkan dengan cepat. Panduan ini menunjukkan + cara memuat sumber data, mengaitkannya dengan templat HTML, memproses templat, dan + menulis file output. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Simpan Hasil HTML yang Dihasilkan – Panduan Template Langkah demi Langkah +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Simpan Hasil HTML yang Dihasilkan – Panduan Lengkap Pemrosesan Template +url: /id/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Simpan Hasil HTML yang Dihasilkan – Panduan Pemrosesan Template Lengkap + +Pernah bertanya-tanya bagaimana cara **menyimpan hasil HTML yang dihasilkan** tanpa membuat rambut Anda rontok? Anda bukan satu‑satunya. Baik Anda sedang membangun static site generator, mesin templating email, atau hanya perlu menumpahkan beberapa data ke halaman yang diformat dengan rapi, langkah‑langkahnya ternyata sangat sederhana setelah Anda memecahnya. + +Dalam tutorial ini kami akan membahas setiap tahap—dari **memuat sumber data** hingga **binding template HTML**, kemudian **memproses template**, dan akhirnya **menyimpan hasil HTML yang dihasilkan**. Pada akhir tutorial Anda akan memiliki program Java siap‑jalankan yang menghasilkan file `result.html` terisi di folder proyek Anda. + +## Apa yang Akan Anda Pelajari + +- Cara membaca data XML atau JSON menggunakan kelas helper kecil. +- Cara memuat file HTML yang berisi placeholder bergaya `${...}`. +- Bagaimana `TemplateProcessor` bawaan menggantikan placeholder tersebut dengan nilai sebenarnya. +- Cara menulis HTML akhir ke disk sehingga sistem lain dapat menggunakannya. + +Tanpa pustaka eksternal, tanpa sihir yang misterius—hanya Java murni dan beberapa kelas intuitif. Buka IDE favorit Anda (IntelliJ, Eclipse, atau bahkan VS Code) dan mari mulai. + +--- + +## Simpan Hasil HTML yang Dihasilkan – Ikhtisar + +Sebelum kita masuk ke kode, bayangkan alur kerja keseluruhan: + +1. **Muat sumber data** – XML atau JSON yang berisi nilai dinamis. +2. **Muat template HTML** – file statis dengan ekspresi binding data. +3. **Proses template** – ganti setiap ekspresi dengan data yang cocok. +4. **Simpan hasil HTML yang dihasilkan** – tulis markup yang telah terisi ke file baru. + +Anggaplah ini sebagai lini perakitan sederhana: bahan mentah (data) → cetak biru (template) → produk jadi (HTML). Setiap tahap bersifat independen, sehingga pengujian dan debugging menjadi sangat mudah. + +--- + +### Langkah 1: Muat Sumber Data + +Hal pertama yang kita butuhkan adalah sebuah kontainer yang dapat membaca baik XML maupun JSON. Pada contoh ini kami tetap menggunakan XML karena lebih mudah divisualisasikan, namun menggantinya dengan JSON hanya memerlukan perubahan satu kelas. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Mengapa ini penting:** Memuat sumber data di awal memberi kita satu sumber kebenaran untuk semua placeholder. Jika XML tidak valid, kita akan mengetahuinya segera—tidak ada bug misterius ketika template mencoba mengikat nilai. + +> **Tip profesional:** Jaga XML Anda tetap rapi dan hindari nesting yang dalam; struktur datar memetakan placeholder `${field}` dengan lebih bersih. + +--- + +### Langkah 2: Muat Template HTML (Binding Template HTML) + +Selanjutnya kita memuat file HTML statis yang berisi ekspresi binding. Placeholder menggunakan sintaks `${key}`, yang secara otomatis dikenali oleh processor. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Mengapa dilakukan seperti ini:** Dengan membiarkan template asli tidak berubah, Anda dapat menggunakan file yang sama untuk berbagai set data. Ini juga memudahkan unit‑testing processor: beri string, verifikasi output, dan Anda tidak perlu menyentuh sistem file lagi. + +--- + +### Langkah 3: Proses Template (Process Template) + +Sekarang masuk ke inti operasi: menukar placeholder dengan nilai nyata. `TemplateProcessor` menelusuri DOM yang telah kita muat sebelumnya, mengekstrak nilai, dan menyuntikkannya ke dalam string HTML. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**Apa yang terjadi di balik layar?** Processor mengiterasi setiap elemen dalam dokumen XML, membangun token `${key}`, dan melakukan `String.replace` sederhana. Ini bukan yang paling cepat untuk file berukuran sangat besar, tetapi untuk skenario template tipikal sudah lebih dari cukup dan menjaga kode tetap mudah dibaca. + +> **Catatan kasus tepi:** Jika sebuah placeholder muncul lebih dari sekali, `replace` akan menangani semua kemunculannya. Jika sebuah kunci tidak ada di XML, token tetap tidak berubah—sangat membantu untuk menemukan data yang hilang saat QA. + +--- + +### Langkah 4: Simpan Hasil HTML yang Dihasilkan + +Akhirnya, kita menyimpan markup yang telah terisi ke disk. Di sinilah frasa **save generated HTML result** benar‑benar bersinar. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Mengapa Anda harus peduli:** Menulis file adalah tindakan terakhir yang menentukan. Setelah HTML berada di disk, Anda dapat menyajikannya dengan web server, mengirimkannya ke konverter PDF, atau mengirimkannya sebagai newsletter. Metode `save` menyembunyikan boilerplate I/O, sehingga logika utama Anda tetap bersih dan fokus pada transformasi. + +--- + +## Pertanyaan Umum & Tips + +- **Bisakah saya menggunakan JSON alih‑alih XML?** + Tentu saja. Ganti `TemplateData` dengan kelas yang mem‑parse JSON (Jackson `ObjectMapper` bekerja dengan baik) dan sesuaikan metode `process` untuk membaca pasangan kunci/nilai dari `Map`. + +- **Bagaimana jika placeholder saya mengandung spasi atau karakter khusus + + +## Apa yang Harus Anda Pelajari Selanjutnya? + + +Tutorial berikut mencakup topik‑topik terkait yang membangun teknik yang ditunjukkan dalam panduan ini. Setiap sumber daya menyertakan contoh kode lengkap yang berfungsi dengan penjelasan langkah‑demi‑langkah untuk membantu Anda menguasai fitur API tambahan dan mengeksplorasi pendekatan implementasi alternatif dalam proyek Anda sendiri. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/italian/java/saving-html-documents/_index.md b/html/italian/java/saving-html-documents/_index.md index 90792cc426..c628bccf4d 100644 --- a/html/italian/java/saving-html-documents/_index.md +++ b/html/italian/java/saving-html-documents/_index.md @@ -54,9 +54,12 @@ Converti facilmente HTML in Markdown usando Aspose.HTML per Java. Segui questa g Scopri come salvare i documenti HTML come MHTML utilizzando Aspose.HTML per Java con questa guida dettagliata, completa di esempi di codice e suggerimenti pratici. ### [Salva il documento SVG in Aspose.HTML per Java](./save-svg-document/) Scopri come salvare i documenti SVG utilizzando Aspose.HTML per Java con questa semplice guida passo dopo passo ricca di esempi. +### [Salva il risultato HTML generato – Guida completa all'elaborazione del modello](./save-generated-html-result-full-template-processing-guide/) +Scopri come salvare il risultato HTML generato usando Aspose.HTML per Java con una guida completa al processing dei template. + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/italian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/italian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..eb5f1910df --- /dev/null +++ b/html/italian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,283 @@ +--- +category: general +date: 2026-07-08 +description: Salva facilmente il risultato HTML generato con questo tutorial passo‑passo + che ti guida nel caricamento dei dati, nell'elaborazione di un modello HTML e nella + scrittura del file finale. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: it +lastmod: 2026-07-08 +og_description: Salva rapidamente il risultato HTML generato. Questa guida ti mostra + come caricare una fonte di dati, associarla a un modello HTML, elaborare il modello + e scrivere il file di output. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Salva il risultato HTML generato – Guida passo‑passo al modello +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Salva il risultato HTML generato – Guida completa al processamento dei template +url: /it/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Salva il risultato HTML generato – Guida completa alla elaborazione del modello + +Ti sei mai chiesto come **salvare il risultato HTML generato** senza impazzire? Non sei l’unico. Che tu stia costruendo un generatore di siti statici, un motore di template per email, o semplicemente abbia bisogno di scaricare dei dati in una pagina ben formattata, i passaggi sono sorprendentemente semplici una volta scomposti. + +In questo tutorial percorreremo ogni fase — dal **caricamento della fonte dati** al **binding del template HTML**, poi **elaborazione del template**, e infine **salvataggio del risultato HTML generato**. Alla fine avrai un programma Java pronto all’uso che produce un file `result.html` popolato nella cartella del tuo progetto. + +## Cosa imparerai + +- Come leggere dati XML o JSON usando una piccola classe di supporto. +- Come caricare un file HTML che contiene segnaposti in stile `${...}`. +- Come il `TemplateProcessor` integrato sostituisce quei segnaposti con valori reali. +- Come scrivere l’HTML finale su disco affinché altri sistemi possano consumarlo. + +Nessuna libreria esterna, nessuna magia oscura — solo Java puro e alcune classi intuitive. Prendi il tuo IDE preferito (IntelliJ, Eclipse o anche VS Code) e cominciamo. + +--- + +## Salva il risultato HTML generato – Panoramica + +Prima di immergerci nel codice, immaginiamo l’intera pipeline: + +1. **Carica la fonte dati** – XML o JSON che contiene i valori dinamici. +2. **Carica il template HTML** – un file statico con espressioni di binding. +3. **Elabora il template** – sostituisci ogni espressione con i dati corrispondenti. +4. **Salva il risultato HTML generato** – scrivi il markup popolato in un nuovo file. + +Pensalo come una semplice catena di montaggio: materia prima (dati) → progetto (template) → prodotto finito (HTML). Ogni fase è indipendente, il che rende test e debug un gioco da ragazzi. + +--- + +### Passo 1: Carica la fonte dati + +La prima cosa di cui abbiamo bisogno è un contenitore che sappia leggere sia XML sia JSON. In questo esempio useremo XML perché è più facile da visualizzare, ma passare a JSON è solo questione di cambiare una classe. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Perché è importante:** Caricare la fonte dati subito ci fornisce una singola fonte di verità per tutti i segnaposti. Se l’XML è malformato, lo sapremo subito — niente bug misteriosi più tardi quando il template tenta di associare i valori. + +> **Consiglio esperto:** Mantieni il tuo XML ordinato ed evita annidamenti profondi; le strutture piatte si mappano più facilmente ai segnaposti `${field}`. + +--- + +### Passo 2: Carica il template HTML (HTML Template Binding) + +Ora importiamo il file HTML statico che contiene le espressioni di binding. I segnaposti seguono la sintassi `${key}`, che il processore riconosce automaticamente. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Perché lo facciamo così:** Tenendo intatto il template originale, puoi riutilizzare lo stesso file per più set di dati. Inoltre semplifica il testing unitario del processore: fornisci una stringa, verifica l’output, e non dovrai più toccare il file system. + +--- + +### Passo 3: Elabora il template (Process Template) + +Ora arriva il cuore dell’operazione: sostituire i segnaposti con valori reali. Il `TemplateProcessor` percorre il DOM caricato in precedenza, estrae i valori e li inietta nella stringa HTML. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**Cosa succede dietro le quinte?** Il processore itera su ogni elemento del documento XML, costruisce un token `${key}` e esegue un semplice `String.replace`. Non è la soluzione più performante per file enormi, ma per scenari tipici di template è più che sufficiente e mantiene il codice leggibile. + +> **Nota su casi limite:** Se un segnaposto appare più volte, `replace` gestirà tutte le occorrenze. Se una chiave manca nell’XML, il token rimane invariato — ottimo per individuare dati mancanti durante il QA. + +--- + +### Passo 4: Salva il risultato HTML generato + +Infine, persistiamo il markup popolato su disco. È qui che la frase **save generated HTML result** prende davvero senso. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Perché è importante:** Scrivere il file è l’ultima azione decisiva. Una volta che l’HTML è su disco puoi servirlo con un web server, passarne il contenuto a un convertitore PDF, o inviarlo come newsletter. Il metodo `save` nasconde il boilerplate I/O, così la logica principale rimane pulita e focalizzata sulla trasformazione. + +--- + +## Domande frequenti e consigli + +- **Posso usare JSON invece di XML?** + Assolutamente. Sostituisci `TemplateData` con una classe che analizza JSON (ad esempio `ObjectMapper` di Jackson) e adatta il metodo `process` per leggere coppie chiave/valore da una `Map`. + +- **Cosa succede se i miei segnaposti contengono spazi o caratteri speciali** + (Il contenuto originale era incompleto; tradotto il testo disponibile.) + +## Cosa dovresti imparare dopo? + +I tutorial seguenti trattano argomenti strettamente correlati che si basano sulle tecniche dimostrate in questa guida. Ogni risorsa include esempi di codice completi e funzionanti con spiegazioni passo‑passo per aiutarti a padroneggiare funzionalità API aggiuntive ed esplorare approcci di implementazione alternativi nei tuoi progetti. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/japanese/java/saving-html-documents/_index.md b/html/japanese/java/saving-html-documents/_index.md index fc0ec241f9..6503a61c0f 100644 --- a/html/japanese/java/saving-html-documents/_index.md +++ b/html/japanese/java/saving-html-documents/_index.md @@ -54,9 +54,12 @@ Aspose.HTML for Java を使用して、HTML を Markdown に簡単に変換で コード例と実用的なヒントが満載のこのステップバイステップ ガイドで、Aspose.HTML for Java を使用して HTML ドキュメントを MHTML として保存する方法を学びます。 ### [Aspose.HTML for Java で SVG ドキュメントを保存する](./save-svg-document/) 例が満載の簡単なステップバイステップ ガイドを使用して、Aspose.HTML for Java を使用して SVG ドキュメントを保存する方法を学びます。 +### [生成された HTML 結果の保存 – 完全テンプレート処理ガイド](./save-generated-html-result-full-template-processing-guide/) +テンプレート全体を処理し、生成された HTML 結果を保存する方法をステップバイステップで解説します。 + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/japanese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/japanese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..838b182d51 --- /dev/null +++ b/html/japanese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,278 @@ +--- +category: general +date: 2026-07-08 +description: データの読み込み、HTMLテンプレートの処理、最終ファイルの書き出しを順を追って解説するこのステップバイステップチュートリアルで、生成されたHTML結果を簡単に保存できます。 +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: ja +lastmod: 2026-07-08 +og_description: 生成されたHTML結果をすばやく保存します。このガイドでは、データソースを読み込み、HTMLテンプレートにバインドし、テンプレートを処理して出力ファイルを書き込む方法を示します。 +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: 生成されたHTML結果の保存 – ステップバイステップテンプレートガイド +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: 生成されたHTML結果の保存 – 完全テンプレート処理ガイド +url: /ja/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# 生成されたHTML結果の保存 – 完全テンプレート処理ガイド + +生成されたHTML結果を **保存** したいのに、どうすればいいか悩んだことはありませんか？ あなただけではありません。静的サイトジェネレータを作るときでも、メールテンプレートエンジンを構築するときでも、単にデータをきれいに整形したページにダンプしたいときでも、手順を分解すれば意外とシンプルです。 + +このチュートリアルでは、**データソースの読み込み** → **HTMLテンプレートへのバインディング** → **テンプレートの処理** → **生成されたHTML結果の保存** の全工程を順に解説します。最後まで読めば、プロジェクトフォルダに `result.html` を生成する、実行可能なJavaプログラムが手に入ります。 + +## 学べること + +- 小さなヘルパークラスを使ってXMLまたはJSONデータを読み込む方法。 +- `${...}` 形式のプレースホルダーを含むHTMLファイルの読み込み方法。 +- 組み込みの `TemplateProcessor` がプレースホルダーを実際の値に置き換える仕組み。 +- 最終的なHTMLをディスクに書き出し、他システムで利用できるようにする方法。 + +外部ライブラリは不要、マジックも不要—純粋なJavaと直感的なクラスだけです。好きなIDE（IntelliJ、Eclipse、あるいは VS Code）を開いて、さっそく始めましょう。 + +--- + +## 生成されたHTML結果の保存 – 概要 + +コードに入る前に、全体のパイプラインをイメージしてみましょう。 + +1. **データソースの読み込み** – 動的な値を保持するXMLまたはJSON。 +2. **HTMLテンプレートの読み込み** – データバインディング式を含む静的ファイル。 +3. **テンプレートの処理** – 各式を対応するデータに置き換える。 +4. **生成されたHTML結果の保存** – 埋め込まれたマークアップを新しいファイルに書き出す。 + +これはシンプルな組立ラインのようなものです：原料（データ）→ 設計図（テンプレート）→ 完成品（HTML）。各ステップが独立しているので、テストやデバッグが楽になります。 + +--- + +### 手順 1: データソースの読み込み + +まず最初に、XMLでもJSONでも読み込めるコンテナが必要です。この例では視覚的に分かりやすいXMLを使いますが、JSONに差し替えるのはクラスを1つ変えるだけです。 + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**なぜ重要か:** データソースを早めに読み込むことで、すべてのプレースホルダーの唯一の真実の情報源が確立します。XMLが不正な場合はすぐに分かります—テンプレートがバインドしようとしたときに謎のバグが出ることはありません。 + +> **プロのコツ:** XMLは整然と保ち、深すぎるネストは避けましょう。フラットな構造の方が `${field}` プレースホルダーにマッピングしやすくなります。 + +--- + +### 手順 2: HTMLテンプレートの読み込み（HTMLテンプレートバインディング） + +次に、バインディング式を含む静的HTMLファイルを読み込みます。プレースホルダーは `${key}` 構文で記述され、プロセッサが自動的に認識します。 + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**このやり方の理由:** 元のテンプレートを変更しないことで、同じファイルを複数のデータセットで再利用できます。また、プロセッサのユニットテストが楽になります：文字列を渡して出力を検証すれば、ファイルシステムに触れる必要がありません。 + +--- + +### 手順 3: テンプレートの処理（Process Template） + +いよいよ本番です：プレースホルダーを実際の値に置き換えます。`TemplateProcessor` は先ほど読み込んだDOMを走査し、値を抽出してHTML文字列に注入します。 + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**内部で何が起きているか?** プロセッサはXMLドキュメントの各要素を走査し、`${key}` トークンを作成してシンプルな `String.replace` を実行します。巨大ファイル向けの最高速ではありませんが、典型的なテンプレートシナリオでは十分高速で、コードも読みやすく保てます。 + +> **エッジケースの注意:** プレースホルダーが複数回出現しても `replace` はすべての出現箇所を置換します。XMLにキーが存在しない場合、トークンはそのまま残ります—QA時にデータ欠損をすぐに発見できる便利な振る舞いです。 + +--- + +### 手順 4: 生成されたHTML結果の保存 + +最後に、埋め込まれたマークアップをディスクに永続化します。ここで **save generated HTML result** のフレーズが本領を発揮します。 + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**なぜ重要か:** ファイルを書き出すことが最終的かつ決定的なアクションです。HTMLがディスクに保存されたら、Webサーバで配信したり、PDF変換ツールに渡したり、ニュースレターとしてメール送信したりできます。`save` メソッドはI/Oの定型処理を隠蔽するので、メインロジックは変換に集中できます。 + +--- + +## よくある質問とヒント + +- **JSONを使うことはできますか？** + もちろんです。`TemplateData` をJSONを解析するクラス（例: Jackson の `ObjectMapper`）に置き換え、`process` メソッドで `Map` からキー/バリューを取得するように調整してください。 + +- **プレースホルダーにスペースや特殊文字が含まれる場合はどうすればいいですか** + +## 次に学ぶべきこと + +以下のチュートリアルは、本ガイドで示した手法に密接に関連するトピックを扱っています。各リソースには完全な動作コード例とステップバイステップの解説が含まれており、追加のAPI機能を習得したり、独自プロジェクトで代替実装アプローチを探求したりするのに役立ちます。 + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/korean/java/saving-html-documents/_index.md b/html/korean/java/saving-html-documents/_index.md index adffa30afd..7c95902c89 100644 --- a/html/korean/java/saving-html-documents/_index.md +++ b/html/korean/java/saving-html-documents/_index.md @@ -23,7 +23,7 @@ Java에서 HTML 문서를 처리하는 경우 Aspose.HTML은 다재다능한 라 ## HTML 변환: 문서에서 마크다운으로 - 이제 그 사랑스러운 HTML을 마크다운으로 변환해야 한다면 어떨까요? 복잡하게 들릴지 몰라도 소설을 요약으로 바꾸는 것과 마찬가지입니다. 간단하고 효율적입니다! Aspose.HTML은 HTML 문서를 마크다운 형식으로 변환하는 매끄러운 방법을 제공하여 형식을 조정하는 동안 필수 콘텐츠를 보존할 수 있습니다. 이 변환 프로세스에 대해 궁금하다면 방법에 대한 튜토리얼을 살펴보세요.[Java용 Aspose.HTML에서 HTML을 Markdown으로 변환](./convert-html-to-markdown/). + 이제 그 사랑스러운 HTML을 마크다운으로 변환해야 한다면 어떨까요? 복잡하게 들릴지 몰라도 소설을 요약으로 바꾸는 것과 같습니다. 간단하고 효율적입니다! Aspose.HTML은 HTML 문서를 마크다운 형식으로 변환하는 매끄러운 방법을 제공하여 형식을 조정하는 동안 필수 콘텐츠를 보존할 수 있습니다. 이 변환 프로세스에 대해 궁금하다면 방법에 대한 튜토리얼을 살펴보세요.[Java용 Aspose.HTML에서 HTML을 Markdown으로 변환](./convert-html-to-markdown/). ## SVG 문서 저장: 탐색을 위한 새로운 길 @@ -51,12 +51,14 @@ Aspose.HTML for Java를 사용하여 HTML 문서를 파일로 저장하는 방 ### [Java용 Aspose.HTML에서 HTML을 Markdown으로 변환](./convert-html-to-markdown/) Java용 Aspose.HTML을 사용하여 HTML을 Markdown으로 쉽게 변환하세요. 원활한 콘텐츠 변환 및 조작을 위한 단계별 가이드를 따르세요. ### [Java용 Aspose.HTML에서 HTML을 MHTML로 저장](./save-html-to-mhtml/) -이 단계별 가이드를 통해 Aspose.HTML for Java를 사용하여 HTML 문서를 MHTML로 저장하는 방법을 알아보세요. 이 가이드에는 코드 예제와 실용적인 팁이 포함되어 있습니다. +이 단계별 가이드를 통해 Aspose.HTML for Java를 사용하여 HTML 문서를 MHTML로 저장하는 방법을 알아보세요. 이 가이드에는 코드 예제와 실용적인 팁이 포함됩니다. ### [Java용 Aspose.HTML로 SVG 문서 저장](./save-svg-document/) 이 간단한 단계별 가이드에는 예제가 가득 담겨 있으며, Java용 Aspose.HTML을 사용하여 SVG 문서를 저장하는 방법을 알아보세요. +### [Java용 Aspose.HTML에 생성된 HTML 결과 저장 – 전체 템플릿 처리 가이드](./save-generated-html-result-full-template-processing-guide/) + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/korean/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/korean/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..29c8c7019e --- /dev/null +++ b/html/korean/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,279 @@ +--- +category: general +date: 2026-07-08 +description: 데이터 로드, HTML 템플릿 처리, 최종 파일 작성을 단계별로 안내하는 이 튜토리얼을 통해 생성된 HTML 결과를 쉽게 저장하세요. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: ko +lastmod: 2026-07-08 +og_description: 생성된 HTML 결과를 빠르게 저장하세요. 이 가이드는 데이터 소스를 로드하고, HTML 템플릿에 바인딩한 뒤, 템플릿을 + 처리하고, 출력 파일을 작성하는 방법을 보여줍니다. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: 생성된 HTML 결과 저장 – 단계별 템플릿 가이드 +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: 생성된 HTML 결과 저장 – 전체 템플릿 처리 가이드 +url: /ko/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Save Generated HTML Result – Full Template Processing Guide + +생성된 HTML 결과를 **저장**하는 방법을 고민해 본 적 있나요? 머리카락이 빠질 정도로 복잡하게 느껴질 수 있지만, 실제로는 단계별로 나누면 생각보다 간단합니다. 정적 사이트 생성기, 이메일 템플릿 엔진, 혹은 데이터를 깔끔하게 포맷된 페이지에 덤프하고 싶을 때 모두 적용할 수 있는 절차입니다. + +이번 튜토리얼에서는 **데이터 소스 로드** → **HTML 템플릿 바인딩** → **템플릿 처리** → **생성된 HTML 결과 저장**까지 모든 과정을 차근차근 살펴봅니다. 최종적으로 프로젝트 폴더에 `result.html` 파일을 생성하는 Java 프로그램을 완성하게 됩니다. + +## What You’ll Learn + +- 작은 헬퍼 클래스를 이용해 XML 또는 JSON 데이터를 읽는 방법. +- `${...}` 형태의 플레이스홀더가 포함된 HTML 파일을 로드하는 방법. +- 내장 `TemplateProcessor`가 해당 플레이스홀더를 실제 값으로 교체하는 방식. +- 최종 HTML을 디스크에 저장해 다른 시스템에서 사용할 수 있게 하는 방법. + +외부 라이브러리 없이 순수 Java와 몇 개의 직관적인 클래스만으로 구현합니다. 좋아하는 IDE(IntelliJ, Eclipse, 혹은 VS Code)를 열고 바로 시작해 보세요. + +--- + +## Save Generated HTML Result – Overview + +코드에 들어가기 전에 전체 파이프라인을 한눈에 살펴봅시다: + +1. **데이터 소스 로드** – 동적 값을 담고 있는 XML 또는 JSON. +2. **HTML 템플릿 로드** – 데이터 바인딩 표현식이 포함된 정적 파일. +3. **템플릿 처리** – 각 표현식을 일치하는 데이터로 교체. +4. **생성된 HTML 결과 저장** – 채워진 마크업을 새 파일에 기록. + +원자재(데이터) → 설계도(템플릿) → 완제품(HTML)이라는 간단한 조립 라인이라고 생각하면 됩니다. 각 단계가 독립적이기 때문에 테스트와 디버깅이 매우 수월합니다. + +--- + +### Step 1: Load the Data Source + +먼저 XML 혹은 JSON을 읽을 수 있는 컨테이너가 필요합니다. 여기서는 시각화가 쉬운 XML을 사용하지만, JSON으로 교체하는 것은 클래스 하나만 바꾸면 됩니다. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**왜 중요한가요:** 데이터 소스를 일찍 로드하면 모든 플레이스홀더에 대한 단일 진실 소스가 확보됩니다. XML이 잘못되면 바로 알 수 있어, 템플릿이 값을 바인딩하려 할 때 발생하는 미스테리 버그를 방지합니다. + +> **Pro tip:** XML을 깔끔하게 유지하고 깊은 중첩을 피하세요. 평탄한 구조가 `${field}` 플레이스홀더와 더 잘 매핑됩니다. + +--- + +### Step 2: Load the HTML Template (HTML Template Binding) + +다음으로 바인딩 표현식이 들어 있는 정적 HTML 파일을 불러옵니다. 플레이스홀더는 `${key}` 구문을 따르며, 프로세서가 자동으로 인식합니다. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**이렇게 하는 이유:** 원본 템플릿을 그대로 두면 여러 데이터 세트에 재사용할 수 있습니다. 또한 프로세서를 단위 테스트하기도 쉬워집니다. 문자열을 입력하고 출력 결과를 검증하면 파일 시스템에 접근할 필요가 없습니다. + +--- + +### Step 3: Process the Template (Process Template) + +이제 핵심 작업인 플레이스홀더를 실제 값으로 교체합니다. `TemplateProcessor`가 앞서 로드한 DOM을 순회하면서 값을 추출하고 HTML 문자열에 삽입합니다. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**내부에서 무슨 일이 일어나나요?** 프로세서는 XML 문서의 각 요소를 순회하면서 `${key}` 토큰을 만들고, 간단한 `String.replace`를 수행합니다. 대용량 파일에 최적화된 방법은 아니지만, 일반적인 템플릿 시나리오에서는 충분히 빠르고 코드 가독성도 좋습니다. + +> **Edge case note:** 같은 플레이스홀더가 여러 번 등장하면 `replace`가 모든 발생을 처리합니다. XML에 키가 없으면 토큰이 그대로 남아 QA 단계에서 누락 데이터를 쉽게 발견할 수 있습니다. + +--- + +### Step 4: Save Generated HTML Result + +마지막으로 채워진 마크업을 디스크에 저장합니다. 여기서 **save generated HTML result**라는 문구가 진가를 발휘합니다. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**왜 신경 써야 할까요:** 파일 쓰기는 최종 단계이자 결정적인 행동입니다. HTML이 디스크에 저장되면 웹 서버로 제공하거나 PDF 변환기에 넘기거나 뉴스레터로 이메일 발송하는 등 다양한 후속 작업이 가능합니다. `save` 메서드는 I/O 보일러플레이트를 숨겨 주어 핵심 로직을 깔끔하게 유지할 수 있습니다. + +--- + +## Common Questions & Tips + +- **Can I use JSON instead of XML?** + Absolutely. Replace `TemplateData` with a class that parses JSON (Jackson’s `ObjectMapper` works nicely) and adjust the `process` method to read key/value pairs from a `Map`. + +- **What if my placeholders contain spaces or special characters + +## What Should You Learn Next? + +다음 튜토리얼들은 이번 가이드에서 다룬 기술을 기반으로 하며, 추가적인 API 기능을 마스터하고 다양한 구현 방식을 탐구할 수 있도록 돕습니다. 각 자료는 완전한 코드 예제와 단계별 설명을 포함하고 있습니다. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/polish/java/saving-html-documents/_index.md b/html/polish/java/saving-html-documents/_index.md index 48443b79ee..8cb42e46f4 100644 --- a/html/polish/java/saving-html-documents/_index.md +++ b/html/polish/java/saving-html-documents/_index.md @@ -54,9 +54,12 @@ Dowiedz się, jak zapisać dokument HTML do pliku za pomocą Aspose.HTML dla Jav Dowiedz się, jak zapisywać dokumenty HTML w formacie MHTML za pomocą Aspose.HTML dla Java, korzystając z tego przewodnika krok po kroku, który zawiera przykłady kodu i praktyczne wskazówki. ### [Zapisz dokument SVG w Aspose.HTML dla Java](./save-svg-document/) Dowiedz się, jak zapisywać dokumenty SVG za pomocą Aspose.HTML dla Java, korzystając z tego prostego przewodnika krok po kroku wypełnionego przykładami. +### [Zapisz wygenerowany wynik HTML – Pełny przewodnik przetwarzania szablonu](./save-generated-html-result-full-template-processing-guide/) +Dowiedz się, jak zapisać wygenerowany wynik HTML przy użyciu pełnego przetwarzania szablonu w Aspose.HTML dla Java. + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/polish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/polish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..4896a61ebb --- /dev/null +++ b/html/polish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,282 @@ +--- +category: general +date: 2026-07-08 +description: Zapisz wygenerowany wynik HTML łatwo, korzystając z tego krok po kroku + poradnika, który przeprowadzi Cię przez ładowanie danych, przetwarzanie szablonu + HTML i zapisywanie finalnego pliku. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: pl +lastmod: 2026-07-08 +og_description: Szybko zapisz wygenerowany wynik HTML. Ten przewodnik pokazuje, jak + wczytać źródło danych, powiązać je z szablonem HTML, przetworzyć szablon i zapisać + plik wyjściowy. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Zapisz wygenerowany wynik HTML – Przewodnik szablonu krok po kroku +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Zapisz wygenerowany wynik HTML – Pełny przewodnik przetwarzania szablonów +url: /pl/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Zapisz wygenerowany wynik HTML – Przewodnik pełnego przetwarzania szablonu + +Zastanawiałeś się kiedyś, jak **zapisać wygenerowany wynik HTML** bez wyrywania sobie włosów? Nie jesteś jedyny. Niezależnie od tego, czy tworzysz generator statycznych stron, silnik szablonów e‑mailowych, czy po prostu potrzebujesz wyrzucić trochę danych na ładnie sformatowaną stronę, kroki są zaskakująco proste, gdy je rozłożymy na czynniki pierwsze. + +W tym tutorialu przejdziemy przez każdy etap — od **załadowania źródła danych** po **wiązanie szablonu HTML**, następnie **przetworzenie szablonu**, a w końcu **zapisanie wygenerowanego wyniku HTML**. Po zakończeniu będziesz mieć gotowy do uruchomienia program w Javie, który tworzy wypełniony plik `result.html` w folderze projektu. + +## Czego się nauczysz + +- Jak odczytać dane XML lub JSON przy użyciu małej klasy pomocniczej. +- Jak załadować plik HTML zawierający placeholdery w stylu `${...}`. +- Jak wbudowany `TemplateProcessor` zamienia te placeholdery na rzeczywiste wartości. +- Jak zapisać finalny HTML na dysku, aby inne systemy mogły go wykorzystać. + +Bez zewnętrznych bibliotek, bez tajemniczej magii — tylko czysta Java i kilka intuicyjnych klas. Chwyć swój ulubiony IDE (IntelliJ, Eclipse lub nawet VS Code) i zaczynamy. + +--- + +## Zapisz wygenerowany wynik HTML – Przegląd + +Zanim przejdziemy do kodu, wyobraźmy sobie cały proces: + +1. **Załaduj źródło danych** – XML lub JSON zawierający dynamiczne wartości. +2. **Załaduj szablon HTML** – statyczny plik z wyrażeniami wiążącymi dane. +3. **Przetwórz szablon** – zamień każde wyrażenie na pasujące dane. +4. **Zapisz wygenerowany wynik HTML** – zapisz wypełniony znacznik do nowego pliku. + +Wyobraź to sobie jako prostą linię montażową: surowiec (dane) → projekt (szablon) → gotowy produkt (HTML). Każdy etap jest niezależny, co ułatwia testowanie i debugowanie. + +--- + +### Krok 1: Załaduj źródło danych + +Pierwszą rzeczą, której potrzebujemy, jest kontener potrafiący odczytać zarówno XML, jak i JSON. W tym przykładzie zostaniemy przy XML, ponieważ łatwiej go zwizualizować, ale zamiana na JSON to tylko zmiana jednej klasy. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Dlaczego to ważne:** Wczesne załadowanie źródła danych daje nam jedyne źródło prawdy dla wszystkich placeholderów. Jeśli XML jest niepoprawny, dowiemy się o tym od razu — nie pojawią się później tajemnicze błędy, gdy szablon będzie próbował wiązać wartości. + +> **Pro tip:** Trzymaj XML w porządku i unikaj głębokiego zagnieżdżania; płaskie struktury lepiej mapują się na placeholdery `${field}`. + +--- + +### Krok 2: Załaduj szablon HTML (HTML Template Binding) + +Następnie wczytujemy statyczny plik HTML, który zawiera wyrażenia wiążące. Placeholdery używają składni `${key}`, którą procesor rozpoznaje automatycznie. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Dlaczego robimy to w ten sposób:** Zachowując oryginalny szablon nietknięty, możesz używać tego samego pliku dla wielu zestawów danych. Ułatwia to także testowanie jednostkowe procesora: podajesz mu ciąg znaków, weryfikujesz wynik i nie musisz już dotykać systemu plików. + +--- + +### Krok 3: Przetwórz szablon (Process Template) + +Teraz dochodzi serce operacji: zamiana placeholderów na rzeczywiste wartości. `TemplateProcessor` przegląda DOM, który wczytaliśmy wcześniej, wyciąga wartości i wstrzykuje je do łańcucha HTML. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**Co dzieje się pod maską?** Procesor iteruje po każdym elemencie dokumentu XML, buduje token `${key}` i wykonuje proste `String.replace`. To nie jest najwydajniejsze rozwiązanie dla ogromnych plików, ale w typowych scenariuszach szablonowych jest w zupełności wystarczające i utrzymuje kod czytelnym. + +> **Uwaga o przypadkach brzegowych:** Jeśli placeholder pojawi się więcej niż raz, `replace` obsłuży wszystkie wystąpienia. Jeśli klucz nie istnieje w XML, token pozostanie niezmieniony — co świetnie sprawdza się przy wykrywaniu brakujących danych w QA. + +--- + +### Krok 4: Zapisz wygenerowany wynik HTML + +Na koniec zapisujemy wypełniony znacznik na dysku. To właśnie tutaj fraza **save generated HTML result** naprawdę nabiera sensu. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Dlaczego to istotne:** Zapis pliku to ostatnia, decydująca akcja. Gdy HTML znajdzie się na dysku, możesz go serwować za pomocą serwera WWW, przekazać konwerterowi PDF lub wysłać jako newsletter. Metoda `save` ukrywa szablonowy kod I/O, więc główna logika pozostaje czysta i skoncentrowana na transformacji. + +--- + +## Często zadawane pytania i wskazówki + +- **Czy mogę używać JSON zamiast XML?** + Oczywiście. Zamień `TemplateData` na klasę parsującą JSON (np. `ObjectMapper` z Jacksona) i dostosuj metodę `process`, aby odczytywała pary klucz/wartość z `Map`. + +- **Co jeśli moje placeholdery zawierają spacje lub znaki specjalne** + +## Co powinieneś nauczyć się dalej? + +Poniższe tutoriale dotyczą ściśle powiązanych tematów, które rozwijają techniki przedstawione w tym przewodniku. Każdy zasób zawiera kompletny, działający kod wraz z wyjaśnieniami krok po kroku, aby pomóc Ci opanować dodatkowe funkcje API i odkrywać alternatywne podejścia w własnych projektach. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/portuguese/java/saving-html-documents/_index.md b/html/portuguese/java/saving-html-documents/_index.md index 90e7bceb07..36066b7cdd 100644 --- a/html/portuguese/java/saving-html-documents/_index.md +++ b/html/portuguese/java/saving-html-documents/_index.md @@ -54,9 +54,11 @@ Converta facilmente HTML para Markdown usando Aspose.HTML para Java. Siga este g Aprenda como salvar documentos HTML como MHTML usando Aspose.HTML para Java com este guia passo a passo, completo com exemplos de código e dicas práticas. ### [Salvar documento SVG em Aspose.HTML para Java](./save-svg-document/) Aprenda como salvar documentos SVG usando Aspose.HTML para Java com este guia passo a passo fácil e repleto de exemplos. +### [Salvar Resultado HTML Gerado – Guia Completo de Processamento de Modelo](./save-generated-html-result-full-template-processing-guide/) +Aprenda a salvar o resultado HTML gerado usando o Aspose.HTML para Java, com um guia completo de processamento de modelos. {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/portuguese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/portuguese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..37e375ddc8 --- /dev/null +++ b/html/portuguese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,282 @@ +--- +category: general +date: 2026-07-08 +description: Salve o resultado HTML gerado facilmente com este tutorial passo a passo + que orienta você a carregar os dados, processar um modelo HTML e escrever o arquivo + final. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: pt +lastmod: 2026-07-08 +og_description: Salve rapidamente o resultado HTML gerado. Este guia mostra como carregar + uma fonte de dados, vinculá‑la a um modelo HTML, processar o modelo e gravar o arquivo + de saída. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Salvar Resultado HTML Gerado – Guia de Modelo Passo a Passo +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Salvar Resultado HTML Gerado – Guia Completo de Processamento de Templates +url: /pt/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Salvar Resultado HTML Gerado – Guia Completo de Processamento de Template + +Já se perguntou como **salvar o resultado HTML gerado** sem pirar? Você não está sozinho. Seja construindo um gerador de sites estáticos, um motor de templates de e‑mail, ou apenas precisando despejar alguns dados em uma página bem formatada, os passos são surpreendentemente simples quando você os divide. + +Neste tutorial vamos percorrer cada etapa — desde **carregar a fonte de dados** até **vinculação do template HTML**, depois **processar o template**, e finalmente **salvar o resultado HTML gerado**. Ao final, você terá um programa Java pronto‑para‑executar que produz um arquivo `result.html` preenchido na pasta do seu projeto. + +## O que você aprenderá + +- Como ler dados XML ou JSON usando uma pequena classe auxiliar. +- Como carregar um arquivo HTML que contém placeholders no estilo `${...}`. +- Como o `TemplateProcessor` embutido troca esses placeholders por valores reais. +- Como escrever o HTML final no disco para que outros sistemas o consumam. + +Sem bibliotecas externas, sem mágica obscura — apenas Java puro e algumas classes intuitivas. Pegue sua IDE favorita (IntelliJ, Eclipse ou até VS Code) e vamos começar. + +--- + +## Salvar Resultado HTML Gerado – Visão Geral + +Antes de mergulharmos no código, imagine todo o pipeline: + +1. **Carregar a fonte de dados** – XML ou JSON que contém os valores dinâmicos. +2. **Carregar o template HTML** – um arquivo estático com expressões de vinculação de dados. +3. **Processar o template** – substituir cada expressão pelo dado correspondente. +4. **Salvar o resultado HTML gerado** – gravar o markup preenchido em um novo arquivo. + +Pense nisso como uma linha de montagem simples: matéria‑prima (dados) → projeto (template) → produto final (HTML). Cada etapa é independente, o que facilita testes e depuração. + +--- + +### Etapa 1: Carregar a Fonte de Dados + +A primeira coisa que precisamos é de um contêiner que saiba ler XML ou JSON. Neste exemplo vamos ficar com XML porque é fácil de visualizar, mas trocar para JSON é apenas uma questão de mudar uma classe. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Por que isso importa:** Carregar a fonte de dados cedo nos dá uma única fonte de verdade para todos os placeholders. Se o XML estiver malformado, saberemos imediatamente — sem bugs misteriosos depois, quando o template tentar vincular valores. + +> **Dica de especialista:** Mantenha seu XML organizado e evite aninhamento profundo; estruturas planas mapeiam mais facilmente para placeholders `${field}`. + +--- + +### Etapa 2: Carregar o Template HTML (Vinculação de Template HTML) + +Em seguida, trazemos o arquivo HTML estático que contém as expressões de vinculação. Os placeholders seguem a sintaxe `${key}`, que o processador reconhece automaticamente. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Por que fazemos assim:** Ao manter o template original intacto, você pode reutilizar o mesmo arquivo para vários conjuntos de dados. Também facilita o teste unitário do processador: alimente‑o com uma string, verifique a saída, e você nunca precisa tocar no sistema de arquivos novamente. + +--- + +### Etapa 3: Processar o Template (Processar Template) + +Agora vem o coração da operação: trocar placeholders por valores reais. O `TemplateProcessor` percorre o DOM que carregamos anteriormente, extrai os valores e os injeta na string HTML. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**O que acontece nos bastidores?** O processador itera sobre cada elemento no documento XML, cria um token `${key}` e realiza um simples `String.replace`. Não é a solução mais performática para arquivos enormes, mas para cenários típicos de templates é mais que suficiente e mantém o código legível. + +> **Observação de caso extremo:** Se um placeholder aparecer mais de uma vez, `replace` tratará todas as ocorrências. Se uma chave estiver ausente no XML, o token permanecerá intacto — ótimo para identificar dados faltantes durante o QA. + +--- + +### Etapa 4: Salvar Resultado HTML Gerado + +Finalmente, persistimos o markup preenchido no disco. É aqui que a expressão **save generated HTML result** realmente brilha. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Por que isso importa:** Gravar o arquivo é a última ação decisiva. Uma vez que o HTML está no disco, você pode servi‑lo com um servidor web, enviá‑lo para um conversor PDF ou usá‑lo como newsletter. O método `save` oculta a boilerplate de I/O, mantendo sua lógica principal limpa e focada na transformação. + +--- + +## Perguntas Frequentes & Dicas + +- **Posso usar JSON em vez de XML?** + Absolutamente. Substitua `TemplateData` por uma classe que faça o parsing de JSON (o `ObjectMapper` do Jackson funciona bem) e ajuste o método `process` para ler pares chave/valor de um `Map`. + +- **E se meus placeholders contiverem espaços ou caracteres especiais** + +## O que Você Deve Aprender a Seguir? + +Os tutoriais a seguir abordam tópicos estreitamente relacionados que ampliam as técnicas demonstradas neste guia. Cada recurso inclui exemplos de código completos e funcionais com explicações passo a passo para ajudá‑lo a dominar recursos adicionais da API e explorar abordagens alternativas de implementação em seus próprios projetos. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/russian/java/saving-html-documents/_index.md b/html/russian/java/saving-html-documents/_index.md index e791842496..11dad1ebf7 100644 --- a/html/russian/java/saving-html-documents/_index.md +++ b/html/russian/java/saving-html-documents/_index.md @@ -51,12 +51,14 @@ url: /ru/java/saving-html-documents/ ### [Конвертировать HTML в Markdown в Aspose.HTML для Java](./convert-html-to-markdown/) Легко конвертируйте HTML в Markdown с помощью Aspose.HTML для Java. Следуйте этому пошаговому руководству для плавного преобразования и манипуляции контентом. ### [Сохраните HTML в MHTML в Aspose.HTML для Java](./save-html-to-mhtml/) -Узнайте, как сохранять HTML-документы в формате MHTML с помощью Aspose.HTML для Java, с помощью этого пошагового руководства, дополненного примерами кода и практическими советами. +Узнайте, как сохранять HTML-документы в формате MHTML с помощью Aspose.HTML для Java, с помощью этого пошагового руководства, дополненного примеров кода и практическими советами. ### [Сохраните документ SVG в Aspose.HTML для Java](./save-svg-document/) Узнайте, как сохранять документы SVG с помощью Aspose.HTML для Java, с помощью этого простого пошагового руководства, полного примеров. +### [Сохранить сгенерированный HTML‑результат — Полное руководство по обработке шаблона](./save-generated-html-result-full-template-processing-guide/) +Узнайте, как сохранять сгенерированный HTML‑результат, используя полное руководство по обработке шаблонов в Aspose.HTML для Java. {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/russian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/russian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..b145c408b0 --- /dev/null +++ b/html/russian/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,273 @@ +--- +category: general +date: 2026-07-08 +description: Легко сохраняйте сгенерированный HTML‑результат с помощью этого пошагового + руководства, которое проведёт вас через загрузку данных, обработку HTML‑шаблона + и запись конечного файла. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: ru +lastmod: 2026-07-08 +og_description: Быстро сохраняйте сгенерированный HTML‑результат. В этом руководстве + показано, как загрузить источник данных, привязать его к HTML‑шаблону, обработать + шаблон и записать выходной файл. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Сохранить сгенерированный HTML‑результат — пошаговое руководство по шаблону +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Сохранить сгенерированный HTML‑результат – Полное руководство по обработке + шаблонов +url: /ru/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Сохранить сгенерированный HTML‑результат – Полное руководство по обработке шаблона + +Когда‑нибудь задумывались, как **сохранить сгенерированный HTML‑результат** без потери волос? Вы не одиноки. Будь то создание статического генератора сайтов, движка шаблонов для email‑рассылок или просто необходимость вывести данные на красиво оформленную страницу — шаги удивительно просты, как только их разбить на части. + +В этом руководстве мы пройдём каждый этап — от **загрузки источника данных** до **привязки HTML‑шаблона**, затем **обработки шаблона** и, наконец, **сохранения сгенерированного HTML‑результата**. К концу вы получите готовую к запуску Java‑программу, которая создаст заполненный файл `result.html` в папке вашего проекта. + +## Что вы узнаете + +- Как читать данные XML или JSON с помощью небольшого вспомогательного класса. +- Как загрузить HTML‑файл, содержащий плейсхолдеры в стиле `${...}`. +- Как встроенный `TemplateProcessor` заменяет эти плейсхолдеры реальными значениями. +- Как записать окончательный HTML на диск, чтобы другие системы могли его использовать. + +Никаких внешних библиотек, никакой магии — только чистый Java и несколько интуитивных классов. Возьмите ваш любимый IDE (IntelliJ, Eclipse или даже VS Code) и приступаем. + +--- + +## Сохранить сгенерированный HTML‑результат – Обзор + +Прежде чем погрузиться в код, представьте весь конвейер: + +1. **Load the data source** – XML или JSON, содержащий динамические значения. +2. **Load the HTML template** – статический файл с выражениями привязки данных. +3. **Process the template** – заменить каждое выражение соответствующими данными. +4. **Save the generated HTML result** – записать заполненную разметку в новый файл. + +Думайте об этом как о простой сборочной линии: сырой материал (данные) → чертёж (шаблон) → готовый продукт (HTML). Каждый этап независим, что упрощает тестирование и отладку. + +### Шаг 1: Загрузка источника данных + +Первое, что нам нужно, — контейнер, умеющий читать XML или JSON. В этом примере мы останемся на XML, потому что его проще визуализировать, но переход на JSON сводится к замене одного класса. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Почему это важно:** Раннее чтение источника данных даёт единую точку правды для всех плейсхолдеров. Если XML некорректен, мы узнаем об этом сразу — никаких загадочных багов позже, когда шаблон будет пытаться привязать значения. + +> **Pro tip:** Держите ваш XML аккуратным и избегайте глубокой вложенности; плоские структуры легче сопоставляются с плейсхолдерами `${field}`. + +### Шаг 2: Загрузка HTML‑шаблона (HTML Template Binding) + +Далее мы загружаем статический HTML‑файл, содержащий выражения привязки. Плейсхолдеры используют синтаксис `${key}`, который процессор распознаёт автоматически. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Почему мы делаем так:** Оставляя оригинальный шаблон нетронутым, вы можете переиспользовать один и тот же файл для разных наборов данных. Это также упрощает юнит‑тестирование процессора: подаёте строку, проверяете вывод и больше не трогаете файловую систему. + +### Шаг 3: Обработка шаблона (Process Template) + +Теперь наступает сердце операции: замена плейсхолдеров реальными значениями. `TemplateProcessor` проходит по DOM, загруженному ранее, извлекает значения и внедряет их в строку HTML. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**Что происходит под капотом?** Процессор перебирает каждый элемент XML‑документа, формирует токен `${key}` и выполняет простую замену `String.replace`. Это не самый быстрый способ для огромных файлов, но для типичных сценариев шаблонов более чем достаточен и сохраняет читаемость кода. + +> **Edge case note:** Если плейсхолдер встречается более одного раза, `replace` обработает все вхождения. Если ключ отсутствует в XML, токен останется нетронутым — это удобно для обнаружения недостающих данных во время QA. + +### Шаг 4: Сохранить сгенерированный HTML‑результат + +Наконец, мы сохраняем заполненную разметку на диск. Здесь фраза **save generated HTML result** действительно раскрывается во всей своей силе. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Почему это важно:** Запись файла — последний решающий шаг. Как только HTML окажется на диске, его можно обслуживать веб‑сервером, передавать в конвертер PDF или отправлять в виде рассылки. Метод `save` скрывает boilerplate ввода‑вывода, поэтому основная логика остаётся чистой и сосредоточенной на трансформации. + +## Часто задаваемые вопросы и советы + +- **Can I use JSON instead of XML?** + Абсолютно. Замените `TemplateData` классом, который парсит JSON (например, `ObjectMapper` из Jackson) и скорректируйте метод `process` так, чтобы он читал пары ключ/значение из `Map`. + +- **What if my placeholders contain spaces or special characters** + +## Что изучать дальше? + +Следующие руководства охватывают тесно связанные темы, построенные на техниках, продемонстрированных в этом гиде. Каждый ресурс включает полностью работающие примеры кода с пошаговыми объяснениями, чтобы помочь вам освоить дополнительные возможности API и исследовать альтернативные подходы в ваших проектах. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/spanish/java/saving-html-documents/_index.md b/html/spanish/java/saving-html-documents/_index.md index 1f584b6dac..788f22ba22 100644 --- a/html/spanish/java/saving-html-documents/_index.md +++ b/html/spanish/java/saving-html-documents/_index.md @@ -54,9 +54,11 @@ Convierta HTML a Markdown fácilmente con Aspose.HTML para Java. Siga esta guía Aprenda a guardar documentos HTML como MHTML usando Aspose.HTML para Java con esta guía paso a paso, completa con ejemplos de código y consejos prácticos. ### [Guardar documento SVG en Aspose.HTML para Java](./save-svg-document/) Aprenda a guardar documentos SVG usando Aspose.HTML para Java con esta sencilla guía paso a paso repleta de ejemplos. +### [Guardar resultado HTML generado – Guía completa de procesamiento de plantillas](./save-generated-html-result-full-template-processing-guide/) +Aprenda a guardar el HTML generado después del procesamiento completo de plantillas con Aspose.HTML para Java, paso a paso. {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/spanish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/spanish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..f1439cac52 --- /dev/null +++ b/html/spanish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,272 @@ +--- +category: general +date: 2026-07-08 +description: Guarda fácilmente el resultado HTML generado con este tutorial paso a + paso que te guía a través de la carga de datos, el procesamiento de una plantilla + HTML y la escritura del archivo final. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: es +lastmod: 2026-07-08 +og_description: Guarda rápidamente el resultado HTML generado. Esta guía te muestra + cómo cargar una fuente de datos, enlazarla a una plantilla HTML, procesar la plantilla + y escribir el archivo de salida. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Guardar el resultado HTML generado – Guía de plantilla paso a paso +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Guardar el resultado HTML generado – Guía completa de procesamiento de plantillas +url: /es/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Guardar el Resultado HTML Generado – Guía Completa de Procesamiento de Plantillas + +¿Alguna vez te has preguntado cómo **guardar el resultado HTML generado** sin volverte loco? No eres el único. Ya sea que estés construyendo un generador de sitios estáticos, un motor de plantillas para correos electrónicos, o simplemente necesites volcar algunos datos en una página bien formateada, los pasos son sorprendentemente simples una vez que los desglosas. + +En este tutorial recorreremos cada etapa—desde **load data source** hasta **HTML template binding**, luego **process template**, y finalmente **save generated HTML result**. Al final tendrás un programa Java listo‑para‑ejecutar que produce un archivo `result.html` poblado en la carpeta de tu proyecto. + +## Lo que aprenderás + +- Cómo leer datos XML o JSON usando una pequeña clase auxiliar. +- Cómo cargar un archivo HTML que contiene marcadores de posición con estilo `${...}`. +- Cómo el `TemplateProcessor` incorporado intercambia esos marcadores de posición por valores reales. +- Cómo escribir el HTML final en disco para que otros sistemas lo consuman. + +Sin bibliotecas externas, sin magia oscura—solo Java puro y algunas clases intuitivas. Agarra tu IDE favorito (IntelliJ, Eclipse o incluso VS Code) y pongámonos a trabajar. + +--- + +## Guardar el Resultado HTML Generado – Visión General + +Antes de sumergirnos en el código, visualicemos todo el flujo: + +1. **Load the data source** – XML o JSON que contiene los valores dinámicos. +2. **Load the HTML template** – un archivo estático con expresiones de enlace de datos. +3. **Process the template** – reemplazar cada expresión con los datos correspondientes. +4. **Save the generated HTML result** – escribir el marcado poblado en un nuevo archivo. + +Piénsalo como una línea de ensamblaje simple: materia prima (datos) → plano (plantilla) → producto terminado (HTML). Cada etapa es independiente, lo que hace que las pruebas y la depuración sean muy fáciles. + +### Paso 1: Cargar la Fuente de Datos + +Lo primero que necesitamos es un contenedor que sepa leer XML o JSON. En este ejemplo nos quedaremos con XML porque es fácil de visualizar, pero cambiar a JSON es solo cuestión de modificar una clase. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Por qué es importante:** Cargar la fuente de datos temprano nos brinda una única fuente de verdad para todos los marcadores de posición. Si el XML está mal formado, lo sabremos de inmediato—sin errores misteriosos más tarde cuando la plantilla intente enlazar valores. + +> **Pro tip:** Mantén tu XML ordenado y evita anidaciones profundas; las estructuras planas se asignan de forma más limpia a los marcadores `${field}`. + +### Paso 2: Cargar la Plantilla HTML (HTML Template Binding) + +A continuación cargamos el archivo HTML estático que contiene las expresiones de enlace. Los marcadores de posición siguen la sintaxis `${key}`, que el procesador reconoce automáticamente. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Why we do it this way:** Al mantener la plantilla original sin tocar, puedes reutilizar el mismo archivo para varios conjuntos de datos. También facilita las pruebas unitarias del procesador: alimentarlo con una cadena, verificar la salida, y nunca volver a tocar el sistema de archivos. + +### Paso 3: Procesar la Plantilla (Process Template) + +Ahora llega el corazón de la operación: intercambiar los marcadores de posición por valores reales. El `TemplateProcessor` recorre el DOM que cargamos antes, extrae los valores y los inserta en la cadena HTML. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**What’s happening under the hood?** El procesador itera sobre cada elemento del documento XML, construye un token `${key}` y realiza un simple `String.replace`. No es lo más eficiente para archivos enormes, pero para escenarios típicos de plantillas es más que suficiente y mantiene el código legible. + +> **Edge case note:** Si un marcador de posición aparece más de una vez, `replace` manejará todas las ocurrencias. Si una clave falta en el XML, el token queda sin tocar—ideal para detectar datos faltantes durante QA. + +### Paso 4: Guardar el Resultado HTML Generado + +Finalmente, persistimos el marcado poblado en disco. Aquí es donde la frase **save generated HTML result** realmente brilla. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Why you should care:** Escribir el archivo es la última acción decisiva. Una vez que el HTML está en disco, puedes servirlo con un servidor web, enviarlo a un convertidor PDF o enviarlo por correo como boletín. El método `save` oculta el código boilerplate de I/O, de modo que tu lógica principal permanece limpia y centrada en la transformación. + +## Preguntas Frecuentes y Consejos + +- **¿Puedo usar JSON en lugar de XML?** + Absolutely. Replace `TemplateData` with a class that parses JSON (Jackson’s `ObjectMapper` works nicely) and adjust the `process` method to read key/value pairs from a `Map`. + +- **¿Qué pasa si mis marcadores de posición contienen espacios o caracteres especiales** + +## ¿Qué Deberías Aprender a Continuación? + +Los siguientes tutoriales cubren temas estrechamente relacionados que se basan en las técnicas demostradas en esta guía. Cada recurso incluye ejemplos de código completos y funcionales con explicaciones paso a paso para ayudarte a dominar características adicionales de la API y explorar enfoques de implementación alternativos en tus propios proyectos. + +- [Cargar Documentos HTML desde Archivo en Aspose.HTML para Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Guardar Documento HTML en Aspose.HTML para Java](/html/english/java/saving-html-documents/save-html-document/) +- [Manejo de Datos y Gestión de Flujos en Aspose.HTML para Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/swedish/java/saving-html-documents/_index.md b/html/swedish/java/saving-html-documents/_index.md index 3b0e49f202..f79a4f8b35 100644 --- a/html/swedish/java/saving-html-documents/_index.md +++ b/html/swedish/java/saving-html-documents/_index.md @@ -54,9 +54,12 @@ Konvertera enkelt HTML till Markdown med Aspose.HTML för Java. Följ denna steg Lär dig hur du sparar HTML-dokument som MHTML med Aspose.HTML för Java med denna steg-för-steg-guide, komplett med kodexempel och praktiska tips. ### [Spara SVG-dokument i Aspose.HTML för Java](./save-svg-document/) Lär dig hur du sparar SVG-dokument med Aspose.HTML för Java med denna enkla steg-för-steg-guide fullpackad med exempel. +### [Spara genererat HTML-resultat – Full guide för mallbearbetning](./save-generated-html-result-full-template-processing-guide/) +Lär dig hur du sparar genererat HTML-resultat med full mallbearbetning i Aspose.HTML för Java. + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/swedish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/swedish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..4f0847f8c7 --- /dev/null +++ b/html/swedish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,284 @@ +--- +category: general +date: 2026-07-08 +description: Spara det genererade HTML-resultatet enkelt med den här steg‑för‑steg‑handledningen + som guidar dig genom att ladda data, bearbeta en HTML-mall och skriva den slutliga + filen. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: sv +lastmod: 2026-07-08 +og_description: Spara genererat HTML-resultat snabbt. Den här guiden visar hur du + laddar en datakälla, binder den till en HTML-mall, bearbetar mallen och skriver + utdatafilen. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Spara genererat HTML‑resultat – Steg‑för‑steg mallguide +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Spara genererat HTML‑resultat – Fullständig guide för mallbearbetning +url: /sv/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Spara genererat HTML‑resultat – Fullständig guide för mallbearbetning + +Har du någonsin funderat på hur du **sparar genererat HTML‑resultat** utan att dra i håret? Du är inte ensam. Oavsett om du bygger en statisk webbplatsgenerator, en e‑post‑mallmotor eller bara behöver dumpa data till en snyggt formaterad sida, är stegen förvånansvärt enkla när du bryter ner dem. + +I den här handledningen går vi igenom varje steg – från **ladda datakälla** till **HTML‑mallbindning**, sedan **bearbeta mallen**, och slutligen **spara genererat HTML‑resultat**. När du är klar har du ett färdigt Java‑program som producerar en ifylld `result.html`‑fil i din projektmapp. + +## Vad du kommer att lära dig + +- Hur du läser XML‑ eller JSON‑data med en liten hjälparklass. +- Hur du laddar en HTML‑fil som innehåller `${...}`‑stilens platshållare. +- Hur den inbyggda `TemplateProcessor` byter ut dessa platshållare mot riktiga värden. +- Hur du skriver den färdiga HTML‑koden till disk så att andra system kan använda den. + +Inga externa bibliotek, ingen mystisk magi – bara ren Java och några intuitiva klasser. Ta fram din favorit‑IDE (IntelliJ, Eclipse eller till och med VS Code) och låt oss köra igång. + +--- + +## Spara genererat HTML‑resultat – Översikt + +Innan vi dyker ner i koden, låt oss föreställa oss hela pipeline:n: + +1. **Ladda datakällan** – XML eller JSON som innehåller de dynamiska värdena. +2. **Ladda HTML‑mallen** – en statisk fil med data‑bindningsuttryck. +3. **Bearbeta mallen** – ersätt varje uttryck med motsvarande data. +4. **Spara det genererade HTML‑resultatet** – skriv den ifyllda markupen till en ny fil. + +Tänk på det som ett enkelt produktionslinje: råmaterial (data) → ritning (mall) → färdig produkt (HTML). Varje steg är oberoende, vilket gör testning och felsökning enkelt. + +--- + +### Steg 1: Ladda datakällan + +Det första vi behöver är en behållare som kan läsa antingen XML eller JSON. I det här exemplet håller vi oss till XML eftersom det är lätt att visualisera, men att byta till JSON är bara en fråga om att byta en klass. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Varför det är viktigt:** Att ladda datakällan tidigt ger oss en enda sanningskälla för alla platshållare. Om XML‑filen är felaktig vet vi det direkt – inga mystiska buggar senare när mallen försöker binda värden. + +> **Proffstips:** Håll din XML prydlig och undvik djup nästling; platta strukturer mappar bättre till `${field}`‑platshållare. + +--- + +### Steg 2: Ladda HTML‑mallen (HTML‑mallbindning) + +Nästa steg är att hämta den statiska HTML‑filen som innehåller bindningsuttrycken. Platshållarna följer syntaxen `${key}`, som processorn automatiskt känner igen. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Varför vi gör så här:** Genom att låta den ursprungliga mallen vara orörd kan du återanvända samma fil för flera **datamängder**. Det gör också enhetstestning av processorn enklare: mata in en sträng, verifiera resultatet, och du behöver aldrig röra filsystemet igen. + +--- + +### Steg 3: Bearbeta mallen (Process Template) + +Nu kommer hjärtat i operationen: att byta ut platshållare mot riktiga värden. `TemplateProcessor` går igenom DOM‑trädet vi laddade tidigare, extraherar värden och injicerar dem i HTML‑strängen. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**Vad som händer under huven:** Processorn itererar över varje element i XML‑dokumentet, bygger ett `${key}`‑token och utför en enkel `String.replace`. Det är inte det mest prestandaeffektiva för enorma filer, men för vanliga mallscenarier räcker det gott och håller koden läsbar. + +> **Edge case‑notering:** Om en platshållare förekommer mer än en gång hanterar `replace` alla förekomster. Om en nyckel saknas i XML‑filen lämnas tokenen orörd – praktiskt för att upptäcka saknad data under QA. + +--- + +### Steg 4: Spara genererat HTML‑resultat + +Till sist sparar vi den ifyllda markupen till disk. Här kommer frasen **save generated HTML result** verkligen till sin rätt. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Varför du bör bry dig:** Att skriva filen är den sista, avgörande handlingen. När HTML‑filen ligger på **disk** kan du servera den med en webbserver, skicka den till en PDF‑konverterare eller e‑posta den som ett nyhetsbrev. `save`‑metoden döljer I/O‑boilerplate, så din huvudlogik förblir ren och fokuserad på transformationen. + +--- + +## Vanliga frågor & tips + +- **Kan jag använda JSON istället för XML?** + Absolut. Byt ut `TemplateData` mot en klass som parsar JSON (Jacksons `ObjectMapper` fungerar bra) och justera `process`‑metoden så att den läser nyckel/värde‑par från en `Map`. + +- **Vad händer om mina platshållare innehåller mellanslag eller specialtecken + + +## Vad bör du lära dig härnäst? + + +Följande handledningar täcker närliggande ämnen som bygger vidare på teknikerna i den här guiden. Varje resurs innehåller kompletta, fungerande kodexempel med steg‑för‑steg‑förklaringar för att hjälpa dig bemästra ytterligare API‑funktioner och utforska alternativa implementationssätt i dina egna projekt. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/thai/java/saving-html-documents/_index.md b/html/thai/java/saving-html-documents/_index.md index 5c29cdfb5a..b25d164f6b 100644 --- a/html/thai/java/saving-html-documents/_index.md +++ b/html/thai/java/saving-html-documents/_index.md @@ -54,9 +54,11 @@ url: /th/java/saving-html-documents/ เรียนรู้วิธีบันทึกเอกสาร HTML เป็น MHTML โดยใช้ Aspose.HTML สำหรับ Java ด้วยคู่มือทีละขั้นตอนนี้ พร้อมด้วยตัวอย่างโค้ดและเคล็ดลับที่เป็นประโยชน์ ### [บันทึกเอกสาร SVG ใน Aspose.HTML สำหรับ Java](./save-svg-document/) เรียนรู้วิธีบันทึกเอกสาร SVG โดยใช้ Aspose.HTML สำหรับ Java ด้วยคู่มือทีละขั้นตอนง่าย ๆ ที่อัดแน่นไปด้วยตัวอย่าง +### [บันทึกผลลัพธ์ HTML ที่สร้าง – คู่มือการประมวลผลเทมเพลตเต็ม](./save-generated-html-result-full-template-processing-guide/) +เรียนรู้วิธีบันทึกผลลัพธ์ HTML ที่สร้างจากการประมวลผลเทมเพลตเต็มด้วย Aspose.HTML สำหรับ Java อย่างละเอียด {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/thai/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/thai/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..f306564bd0 --- /dev/null +++ b/html/thai/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,268 @@ +--- +category: general +date: 2026-07-08 +description: บันทึกผลลัพธ์ HTML ที่สร้างขึ้นได้อย่างง่ายดายด้วยบทแนะนำแบบขั้นตอนต่อขั้นตอนที่นำคุณผ่านการโหลดข้อมูล, + การประมวลผลเทมเพลต HTML, และการเขียนไฟล์สุดท้าย. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: th +lastmod: 2026-07-08 +og_description: บันทึกผลลัพธ์ HTML ที่สร้างขึ้นอย่างรวดเร็ว คู่มือนี้จะแสดงวิธีโหลดแหล่งข้อมูล + ผูกกับเทมเพลต HTML ประมวลผลเทมเพลต และเขียนไฟล์ผลลัพธ์ +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: บันทึกผลลัพธ์ HTML ที่สร้าง – คู่มือเทมเพลตแบบขั้นตอนต่อขั้นตอน +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: บันทึกผลลัพธ์ HTML ที่สร้างขึ้น – คู่มือการประมวลผลเทมเพลตแบบเต็ม +url: /th/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Save Generated HTML Result – คู่มือการประมวลผลเทมเพลตเต็มรูปแบบ + +เคยสงสัยไหมว่าจะแบบไหนที่จะ **save generated HTML result** โดยไม่ต้องบิดหัวของคุณ? คุณไม่ได้เป็นคนเดียว ไม่ว่าคุณจะกำลังสร้าง static site generator, email templating engine, หรือแค่ต้องการดึงข้อมูลบางอย่างไปใส่ในหน้าเว็บที่จัดรูปแบบอย่างสวยงาม ขั้นตอนก็ง่ายกว่าที่คิดเมื่อคุณแยกย่อยมันออก + +ในบทเรียนนี้เราจะเดินผ่านทุกขั้นตอน — ตั้งแต่ **load data source** ไปจนถึง **HTML template binding**, จากนั้น **process template**, และสุดท้าย **save generated HTML result**. เมื่อจบคุณจะมีโปรแกรม Java ที่พร้อมรันซึ่งสร้างไฟล์ `result.html` ที่เติมข้อมูลแล้วในโฟลเดอร์โปรเจคของคุณ + +## สิ่งที่คุณจะได้เรียนรู้ + +- วิธีอ่านข้อมูล XML หรือ JSON ด้วยคลาสช่วยเล็ก ๆ +- วิธีโหลดไฟล์ HTML ที่มีตัวแปรแทน `${...}`‑style +- วิธีที่ `TemplateProcessor` ในตัวเปลี่ยนตัวแปรแทนเหล่านั้นเป็นค่าจริง +- วิธีเขียน HTML สุดท้ายลงดิสก์เพื่อให้ระบบอื่น ๆ สามารถใช้งานได้ + +ไม่มีไลบรารีภายนอก ไม่มีเวทมนตร์ที่ซับซ้อน — เพียง Java ธรรมดาและคลาสที่เข้าใจง่ายไม่กี่ตัว. เปิด IDE ที่คุณชอบ (IntelliJ, Eclipse หรือแม้แต่ VS Code) แล้วมาเริ่มกันเลย + +## Save Generated HTML Result – ภาพรวม + +Before we dive into code, let’s picture the whole pipeline: + +1. **Load the data source** – XML หรือ JSON ที่เก็บค่าที่เปลี่ยนแปลงได้. +2. **Load the HTML template** – ไฟล์สเตติกที่มี expression สำหรับ data‑binding. +3. **Process the template** – แทนที่แต่ละ expression ด้วยข้อมูลที่ตรงกัน. +4. **Save the generated HTML result** – เขียน markup ที่เติมข้อมูลแล้วลงไฟล์ใหม่. + +คิดว่าเป็นสายการประกอบง่าย ๆ: วัตถุดิบ (data) → แผนผัง (template) → ผลลัพธ์สำเร็จ (HTML). แต่ละขั้นตอนเป็นอิสระ ทำให้การทดสอบและดีบักเป็นเรื่องง่าย + +### ขั้นตอนที่ 1: โหลดแหล่งข้อมูล + +The first thing we need is a container that knows how to read either XML or JSON. In this example we’ll stick with XML because it’s easy to visualize, but swapping in JSON is just a matter of changing one class. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**ทำไมเรื่องนี้สำคัญ:** การโหลดแหล่งข้อมูลตั้งแต่แรกทำให้เรามีแหล่งความจริงเดียวสำหรับตัวแปรแทนทั้งหมด. หาก XML มีรูปแบบผิดพลาด เราจะรู้ทันที — ไม่ต้องเจอบั๊กลึกลับเมื่อเทมเพลตพยายามผูกค่า. + +> **เคล็ดลับ:** รักษา XML ให้เป็นระเบียบและหลีกเลี่ยงการซ้อนลึก; โครงสร้างแบบแบนจะแมปกับตัวแปร `${field}` ได้สะอาดตากว่า. + +### ขั้นตอนที่ 2: โหลด HTML Template (HTML Template Binding) + +Next we pull in the static HTML file that contains the binding expressions. The placeholders follow the `${key}` syntax, which the processor recognises automatically. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**ทำไมเราถึงทำแบบนี้:** การไม่แก้ไขเทมเพลตต้นฉบับทำให้คุณสามารถใช้ไฟล์เดียวสำหรับหลายชุดข้อมูล. นอกจากนี้ยังทำให้การ unit‑testing processor ง่ายขึ้น: ป้อนสตริง, ตรวจสอบผลลัพธ์, และคุณไม่ต้องสัมผัสระบบไฟล์อีกเลย. + +### ขั้นตอนที่ 3: ประมวลผลเทมเพลต (Process Template) + +Now comes the heart of the operation: swapping placeholders with real values. The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and injects them into the HTML string. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**อะไรที่เกิดขึ้นเบื้องหลัง?** Processor จะวนลูปแต่ละ element ในเอกสาร XML, สร้าง token `${key}`, และทำ `String.replace` อย่างง่าย. แม้อาจไม่เร็วที่สุดสำหรับไฟล์ขนาดใหญ่, แต่สำหรับสถานการณ์เทมเพลตทั่วไปก็เพียงพอและทำให้โค้ดอ่านง่าย. + +> **หมายเหตุกรณีขอบ:** หากตัวแปรแทนปรากฏหลายครั้ง, `replace` จะจัดการทุกการเกิด. หากคีย์หายไปใน XML, token จะคงอยู่โดยไม่เปลี่ยน—เป็นประโยชน์ในการตรวจจับข้อมูลที่หายไประหว่าง QA. + +### ขั้นตอนที่ 4: บันทึกผลลัพธ์ HTML ที่สร้าง + +Finally, we persist the populated markup to disk. This is where the **save generated HTML result** phrase truly shines. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**ทำไมคุณควรสนใจ:** การเขียนไฟล์เป็นการกระทำสุดท้ายที่สำคัญ. เมื่อ HTML อยู่บนดิสก์แล้วคุณสามารถให้เว็บเซิร์ฟเวอร์เสิร์ฟ, ส่งต่อให้ตัวแปลง PDF, หรืออีเมลเป็นจดหมายข่าว. เมธอด `save` ซ่อนโค้ด boilerplate ของ I/O, ทำให้ตรรกะหลักของคุณสะอาดและมุ่งเน้นที่การแปลง. + +## คำถามทั่วไป & เคล็ดลับ + +- **Can I use JSON instead of XML?** + แน่นอน. แทนที่ `TemplateData` ด้วยคลาสที่ทำการพาร์ส JSON (Jackson’s `ObjectMapper` ทำงานได้ดี) และปรับเมธอด `process` ให้อ่านคู่ key/value จาก `Map`. + +- **What if my placeholders contain spaces or special characters + +## สิ่งที่คุณควรเรียนต่อไป? + +The following tutorials cover closely related topics that build on the techniques demonstrated in this guide. Each resource includes complete working code examples with step-by-step explanations to help you master additional API features and explore alternative implementation approaches in your own projects. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/turkish/java/saving-html-documents/_index.md b/html/turkish/java/saving-html-documents/_index.md index 6705ad60b3..bd6f9d112e 100644 --- a/html/turkish/java/saving-html-documents/_index.md +++ b/html/turkish/java/saving-html-documents/_index.md @@ -54,9 +54,11 @@ Java için Aspose.HTML kullanarak HTML'yi Markdown'a kolayca dönüştürün. So Bu adım adım kılavuzla, kod örnekleri ve pratik ipuçlarıyla birlikte Aspose.HTML for Java kullanarak HTML belgelerini MHTML olarak nasıl kaydedeceğinizi öğrenin. ### [Java için Aspose.HTML'de SVG Belgesini Kaydetme](./save-svg-document/) Örneklerle dolu bu kolay adım adım kılavuzla Java için Aspose.HTML kullanarak SVG belgelerinin nasıl kaydedileceğini öğrenin. +### [Oluşturulan HTML Sonucunu Kaydet – Tam Şablon İşleme Kılavuzu](./save-generated-html-result-full-template-processing-guide/) +Java için Aspose.HTML kullanarak tam şablon işleme ile oluşturulan HTML sonucunu kaydetmeyi öğrenin. {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/turkish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/turkish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..25e2337983 --- /dev/null +++ b/html/turkish/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,281 @@ +--- +category: general +date: 2026-07-08 +description: Bu adım adım öğreticiyle, veri yükleme, HTML şablonunu işleme ve son + dosyayı yazma süreçlerini size göstererek oluşturulan HTML sonucunu kolayca kaydedin. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: tr +lastmod: 2026-07-08 +og_description: Oluşturulan HTML sonucunu hızlı bir şekilde kaydedin. Bu kılavuz, + bir veri kaynağını nasıl yükleyeceğinizi, bir HTML şablonuna bağlayacağınızı, şablonu + işleyeceğinizi ve çıktı dosyasını yazacağınızı gösterir. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Oluşturulan HTML Sonucunu Kaydet – Adım Adım Şablon Rehberi +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Oluşturulan HTML Sonucunu Kaydet – Tam Şablon İşleme Kılavuzu +url: /tr/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Save Generated HTML Result – Full Template Processing Guide + +Hiç **save generated HTML result** ifadesini saçınızı yolmak zorunda kalmadan nasıl kaydedeceğinizi merak ettiniz mi? Tek başınıza değilsiniz. Statik site üreticisi, e‑posta şablon motoru oluşturuyor olun ya da sadece bazı verileri güzel biçimlendirilmiş bir sayfaya dökmek istiyor olun, adımlar veriyi parçaladığınızda şaşırtıcı derecede basit. + +Bu öğreticide **load data source** aşamasından **HTML template binding**, ardından **process template** ve son olarak **save generated HTML result** aşamasına kadar her adımı birlikte ele alacağız. Sonunda, projenizin klasöründe doldurulmuş bir `result.html` dosyası üreten, çalıştırmaya hazır bir Java programına sahip olacaksınız. + +## What You’ll Learn + +- Küçük bir yardımcı sınıf kullanarak XML veya JSON verisini nasıl okuyacağınız. +- `${...}`‑stilindeki yer tutucuları içeren bir HTML dosyasını nasıl yükleyeceğiniz. +- Yerleşik `TemplateProcessor`'ın bu yer tutucuları gerçek değerlerle nasıl değiştirdiği. +- Son HTML'i diske nasıl yazacağınız, böylece diğer sistemlerin tüketebilmesi. + +Harici kütüphane yok, gizli sihir yok—sadece saf Java ve birkaç sezgisel sınıf. Sevdiğiniz IDE'yi (IntelliJ, Eclipse ya da hatta VS Code) kapın ve işe koyulalım. + +--- + +## Save Generated HTML Result – Overview + +Koda dalmadan önce tüm süreci hayal edelim: + +1. **Load the data source** – Dinamik değerleri tutan XML veya JSON. +2. **Load the HTML template** – Veri bağlama ifadeleri içeren statik bir dosya. +3. **Process the template** – Her ifadeyi eşleşen veriyle değiştirmek. +4. **Save the generated HTML result** – Doldurulmuş işaretlemeyi yeni bir dosyaya yazmak. + +Bunu basit bir montaj hattı gibi düşünün: ham madde (veri) → plan (şablon) → bitmiş ürün (HTML). Her aşama bağımsızdır, bu da test ve hata ayıklamayı çok kolaylaştırır. + +--- + +### Step 1: Load the Data Source + +İlk olarak XML ya da JSON okuyabilen bir konteyner gerekir. Bu örnekte görselliği kolay olduğu için XML kullanacağız, ancak JSON’a geçmek sadece bir sınıfı değiştirmek kadar basit. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Why this matters:** Veri kaynağını erken yüklemek, tüm yer tutucular için tek bir gerçek kaynağa sahip olmamızı sağlar. XML hatalıysa hemen fark ederiz—şablon değer bağlamaya çalıştığında gizli hatalarla karşılaşmayız. + +> **Pro tip:** XML’inizi düzenli tutun ve derin iç içe yapılardan kaçının; düz yapılar `${field}` yer tutucularına daha temiz eşlenir. + +--- + +### Step 2: Load the HTML Template (HTML Template Binding) + +Şimdi bağlama ifadelerini içeren statik HTML dosyasını alıyoruz. Yer tutucular `${key}` sözdizimini izler ve işlemci bunu otomatik tanır. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Why we do it this way:** Orijinal şablonu dokunulmaz tutarak aynı dosyayı birden çok veri seti için yeniden kullanabilirsiniz. Ayrıca işlemciyi bir string ile besleyip çıktıyı doğrulamak, dosya sistemine dokunmadan birim testi yapmayı kolaylaştırır. + +--- + +### Step 3: Process the Template (Process Template) + +Şimdi işlemin kalbi devreye giriyor: yer tutucuları gerçek değerlerle değiştirmek. `TemplateProcessor`, daha önce yüklediğimiz DOM’u dolaşır, değerleri çıkarır ve HTML stringine enjekte eder. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**What’s happening under the hood?** İşlemci, XML belgesindeki her öğeyi iterasyonla dolaşır, bir `${key}` tokenı oluşturur ve basit bir `String.replace` uygular. Çok büyük dosyalar için en hızlı çözüm olmasa da tipik şablon senaryoları için fazlasıyla yeterlidir ve kod okunabilirliğini korur. + +> **Edge case note:** Bir yer tutucu birden çok kez görünürse, `replace` tüm oluşumları ele alır. XML’de bir anahtar eksikse token dokunulmaz kalır—QA sırasında eksik veriyi tespit etmeyi kolaylaştırır. + +--- + +### Step 4: Save Generated HTML Result + +Son olarak doldurulmuş işaretlemeyi diske kalıcı olarak kaydediyoruz. İşte **save generated HTML result** ifadesinin gerçek anlam kazandığı nokta. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Why you need care:** Dosyayı yazmak son ve belirleyici adımdır. HTML diske yerleştirildiğinde bir web sunucusuyla sunulabilir, bir PDF dönüştürücüsüne beslenebilir ya da haber bülteni olarak e‑postalanabilir. `save` metodu I/O ayrıntılarını gizler, böylece ana mantığınız dönüşüm üzerine odaklanır ve temiz kalır. + +--- + +## Common Questions & Tips + +- **Can I use JSON instead of XML?** + Kesinlikle. `TemplateData` sınıfını JSON ayrıştıran bir sınıfla (Jackson’ın `ObjectMapper`’ı güzel çalışır) değiştirin ve `process` metodunu `Map` üzerinden anahtar/değer çiftlerini okuyacak şekilde ayarlayın. + +- **What if my placeholders contain spaces or special characters** + +## What Should You Learn Next? + +Aşağıdaki öğreticiler, bu rehberde gösterilen tekniklere dayanan ve ilgili konuları daha derinlemesine ele alan içeriklerdir. Her kaynak, ek API özelliklerini ustalaşmanız ve projelerinizde alternatif uygulama yaklaşımları keşfetmeniz için adım adım açıklamalı tam çalışan kod örnekleri sunar. + +- [Load HTML Documents from File in Aspose.HTML for Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Save HTML Document in Aspose.HTML for Java](/html/english/java/saving-html-documents/save-html-document/) +- [Data Handling and Stream Management in Aspose.HTML for Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/vietnamese/java/saving-html-documents/_index.md b/html/vietnamese/java/saving-html-documents/_index.md index 971c36aef2..ff1f36cf70 100644 --- a/html/vietnamese/java/saving-html-documents/_index.md +++ b/html/vietnamese/java/saving-html-documents/_index.md @@ -54,9 +54,11 @@ Dễ dàng chuyển đổi HTML sang Markdown bằng Aspose.HTML cho Java. Thự Tìm hiểu cách lưu tài liệu HTML dưới dạng MHTML bằng Aspose.HTML cho Java với hướng dẫn từng bước này, kèm theo các ví dụ mã và mẹo thực tế. ### [Lưu tài liệu SVG trong Aspose.HTML cho Java](./save-svg-document/) Tìm hiểu cách lưu tài liệu SVG bằng Aspose.HTML cho Java với hướng dẫn từng bước dễ dàng kèm theo nhiều ví dụ này. +### [Lưu kết quả HTML đã tạo – Hướng dẫn xử lý mẫu đầy đủ](./save-generated-html-result-full-template-processing-guide/) +Khám phá cách lưu kết quả HTML được tạo ra bằng Aspose.HTML cho Java qua hướng dẫn chi tiết toàn diện. {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} {{< /blocks/products/pf/main-wrap-class >}} -{{< blocks/products/products-backtop-button >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/vietnamese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md b/html/vietnamese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md new file mode 100644 index 0000000000..edfe595907 --- /dev/null +++ b/html/vietnamese/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/_index.md @@ -0,0 +1,271 @@ +--- +category: general +date: 2026-07-08 +description: Lưu kết quả HTML đã tạo một cách dễ dàng với hướng dẫn từng bước này, + giúp bạn tải dữ liệu, xử lý mẫu HTML và ghi tệp cuối cùng. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save generated html result +- load data source +- html template binding +- process template +- populate html result +language: vi +lastmod: 2026-07-08 +og_description: Lưu nhanh kết quả HTML đã tạo. Hướng dẫn này chỉ cho bạn cách tải + nguồn dữ liệu, liên kết nó với mẫu HTML, xử lý mẫu và ghi file đầu ra. +og_image_alt: Screenshot of generated HTML file saved to disk after template processing +og_title: Lưu Kết Quả HTML Được Tạo – Hướng Dẫn Mẫu Bước‑Những‑Bước +schemas: +- author: Aspose + dateModified: '2026-07-08' + description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + headline: Save Generated HTML Result – Full Template Processing Guide + type: TechArticle +- description: Save generated HTML result easily with this step‑by‑step tutorial that + walks you through loading data, processing an HTML template, and writing the final + file. + name: Save Generated HTML Result – Full Template Processing Guide + steps: + - name: Load the Data Source + text: The first thing we need is a container that knows how to read either XML + or JSON. In this example we’ll stick with XML because it’s easy to visualize, + but swapping in JSON is just a matter of changing one class. + - name: Load the HTML Template (HTML Template Binding) + text: Next we pull in the static HTML file that contains the binding expressions. + The placeholders follow the `${key}` syntax, which the processor recognises + automatically. + - name: Process the Template (Process Template) + text: 'Now comes the heart of the operation: swapping placeholders with real values. + The `TemplateProcessor` walks the DOM we loaded earlier, extracts values, and + injects them into the HTML string.' + - name: Save Generated HTML Result + text: Finally, we persist the populated markup to disk. This is where the **save + generated HTML result** phrase truly shines. + type: HowTo +tags: +- HTML +- template processing +- Java +- file I/O +title: Lưu Kết Quả HTML Được Tạo – Hướng Dẫn Toàn Diện Xử Lý Mẫu +url: /vi/java/saving-html-documents/save-generated-html-result-full-template-processing-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Lưu Kết Quả HTML Được Tạo – Hướng Dẫn Xử Lý Mẫu Toàn Diện + +Bạn đã bao giờ tự hỏi làm thế nào để **lưu kết quả HTML được tạo** mà không làm rối tóc không? Bạn không phải là người duy nhất. Dù bạn đang xây dựng một trình tạo trang tĩnh, một công cụ tạo mẫu email, hoặc chỉ cần đổ một số dữ liệu vào một trang được định dạng đẹp mắt, các bước thực tế rất đơn giản một khi bạn phân tách chúng. + +Trong tutorial này chúng ta sẽ đi qua từng giai đoạn — từ **load data source** đến **HTML template binding**, sau đó **process template**, và cuối cùng là **save generated HTML result**. Khi kết thúc, bạn sẽ có một chương trình Java sẵn sàng chạy, tạo ra tệp `result.html` đã được điền dữ liệu trong thư mục dự án của bạn. + +## Những Điều Bạn Sẽ Học + +- Cách đọc dữ liệu XML hoặc JSON bằng một lớp trợ giúp nhỏ. +- Cách tải một tệp HTML chứa các placeholder kiểu `${...}`. +- Cách `TemplateProcessor` tích hợp thay thế các placeholder bằng giá trị thực. +- Cách ghi HTML cuối cùng ra đĩa để các hệ thống khác có thể sử dụng. + +Không cần thư viện bên ngoài, không có phép màu khó hiểu — chỉ cần Java thuần và một vài lớp trực quan. Hãy mở IDE yêu thích của bạn (IntelliJ, Eclipse, hoặc thậm chí VS Code) và bắt đầu. + +--- + +## Lưu Kết Quả HTML Được Tạo – Tổng Quan + +Trước khi chúng ta đi sâu vào mã, hãy hình dung toàn bộ quy trình: + +1. **Load the data source** – XML hoặc JSON chứa các giá trị động. +2. **Load the HTML template** – một tệp tĩnh với các biểu thức ràng buộc dữ liệu. +3. **Process the template** – thay thế mỗi biểu thức bằng dữ liệu tương ứng. +4. **Save the generated HTML result** – ghi markup đã được điền vào một tệp mới. + +Hãy nghĩ nó như một dây chuyền lắp ráp đơn giản: nguyên liệu thô (dữ liệu) → bản thiết kế (template) → sản phẩm hoàn thiện (HTML). Mỗi giai đoạn đều độc lập, giúp việc kiểm thử và gỡ lỗi trở nên dễ dàng. + +### Bước 1: Load the Data Source + +Điều đầu tiên chúng ta cần là một container biết cách đọc XML hoặc JSON. Trong ví dụ này chúng ta sẽ dùng XML vì dễ hình dung, nhưng việc chuyển sang JSON chỉ cần thay đổi một lớp. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; +import org.w3c.dom.Document; +import javax.xml.parsers.DocumentBuilderFactory; + +/** + * Simple wrapper that loads an XML file and exposes it as a DOM Document. + * You could extend this to support JSON by using a library like Jackson. + */ +public class TemplateData { + private Document document; + + public TemplateData(String xmlPath) throws Exception { + // Load and parse the XML file – this is the "load data source" step. + this.document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder() + .parse(Files.newInputStream(Paths.get(xmlPath))); + this.document.getDocumentElement().normalize(); + } + + public Document getDocument() { + return document; + } +} +``` + +**Tại sao điều này quan trọng:** Tải nguồn dữ liệu sớm giúp chúng ta có một nguồn chân thực duy nhất cho mọi placeholder. Nếu XML bị lỗi, chúng ta sẽ biết ngay lập tức — không có những lỗi bí ẩn khi template cố gắng ràng buộc giá trị. + +> **Pro tip:** Giữ XML của bạn gọn gàng và tránh lồng quá sâu; cấu trúc phẳng sẽ ánh xạ sạch sẽ hơn tới các placeholder `${field}`. + +### Bước 2: Load the HTML Template (HTML Template Binding) + +Tiếp theo chúng ta tải tệp HTML tĩnh chứa các biểu thức ràng buộc. Các placeholder tuân theo cú pháp `${key}`, mà bộ xử lý sẽ nhận diện tự động. + +```java +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Represents an HTML file that can be processed with data bindings. + */ +public class HTMLDocument { + private String rawHtml; + + public HTMLDocument(String htmlPath) throws Exception { + // Read the entire file into a String – this is the "HTML template binding" step. + this.rawHtml = new String(Files.readAllBytes(Paths.get(htmlPath)), "UTF-8"); + } + + public String getRawHtml() { + return rawHtml; + } + + public TemplateProcessor getTemplateProcessor() { + return new TemplateProcessor(this); + } + + public void save(String outputPath) throws Exception { + // Write the final HTML to disk – the "save generated HTML result" step. + Files.write(Paths.get(outputPath), rawHtml.getBytes("UTF-8")); + } + + // Allows the processor to replace the internal HTML string. + void setProcessedHtml(String processed) { + this.rawHtml = processed; + } +} +``` + +**Tại sao chúng ta làm như vậy:** Bằng cách giữ nguyên template gốc, bạn có thể tái sử dụng cùng một tệp cho nhiều bộ dữ liệu. Điều này cũng làm cho việc unit‑testing bộ xử lý dễ dàng hơn: đưa vào một chuỗi, kiểm tra đầu ra, và bạn không cần chạm vào hệ thống tệp nữa. + +### Bước 3: Process the Template (Process Template) + +Bây giờ là phần cốt lõi của hoạt động: thay thế các placeholder bằng giá trị thực. `TemplateProcessor` duyệt DOM mà chúng ta đã tải, trích xuất giá trị và chèn chúng vào chuỗi HTML. + +```java +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * Very lightweight processor that replaces ${key} tokens + * with values extracted from the XML Document. + */ +public class TemplateProcessor { + private final HTMLDocument htmlDoc; + private final TemplateData data; + + public TemplateProcessor(HTMLDocument htmlDoc) { + this.htmlDoc = htmlDoc; + this.data = null; // will be set later via process() + } + + /** + * Executes the binding – this is the "process template" step. + * + * @param dataSource the loaded XML/JSON data + */ + public void process(TemplateData dataSource) throws Exception { + // Grab the raw HTML string. + String processed = htmlDoc.getRawHtml(); + + // Walk through every element in the XML document. + NodeList nodes = dataSource.getDocument().getDocumentElement().getChildNodes(); + for (int i = 0; i < nodes.getLength(); i++) { + Node node = nodes.item(i); + if (node.getNodeType() != Node.ELEMENT_NODE) continue; + + String key = node.getNodeName(); // e.g., "title" + String value = node.getTextContent(); // e.g., "Hello World" + + // Replace every occurrence of ${key} with its value. + processed = processed.replace("${" + key + "}", value); + } + + // Hand the processed HTML back to the document. + htmlDoc.setProcessedHtml(processed); + } +} +``` + +**Điều gì đang diễn ra phía sau?** Bộ xử lý lặp qua từng phần tử trong tài liệu XML, tạo token `${key}`, và thực hiện một `String.replace` đơn giản. Nó không phải là cách tối ưu nhất cho các tệp rất lớn, nhưng đối với các kịch bản template thông thường thì hoàn toàn đủ và giữ cho mã dễ đọc. + +> **Edge case note:** Nếu một placeholder xuất hiện nhiều lần, `replace` sẽ xử lý tất cả các lần xuất hiện. Nếu một key thiếu trong XML, token sẽ được giữ nguyên — rất hữu ích để phát hiện dữ liệu thiếu trong quá trình QA. + +### Bước 4: Save Generated HTML Result + +Cuối cùng, chúng ta ghi markup đã được điền vào đĩa. Đây là nơi cụm từ **save generated HTML result** thực sự tỏa sáng. + +```java +public class TemplateRunner { + public static void main(String[] args) { + try { + // 1️⃣ Load the data source (XML or JSON) + TemplateData dataSource = new TemplateData("YOUR_DIRECTORY/data.xml"); + + // 2️⃣ Load the HTML template that contains data‑binding expressions + HTMLDocument templateDocument = new HTMLDocument("YOUR_DIRECTORY/template.html"); + + // 3️⃣ Process the template with the loaded data + templateDocument.getTemplateProcessor().process(dataSource); + + // 4️⃣ Save the populated HTML result + templateDocument.save("YOUR_DIRECTORY/result.html"); + + System.out.println("✅ HTML generation complete! Check YOUR_DIRECTORY/result.html"); + } catch (Exception e) { + // In a real project you’d use a logger – this is just for demo purposes. + System.err.println("❌ Something went wrong: " + e.getMessage()); + e.printStackTrace(); + } + } +} +``` + +**Tại sao bạn nên quan tâm:** Việc ghi tệp là hành động quyết định cuối cùng. Khi HTML đã có trên đĩa, bạn có thể phục vụ nó bằng một web server, đưa vào bộ chuyển đổi PDF, hoặc gửi dưới dạng newsletter. Phương thức `save` ẩn đi phần boilerplate I/O, giúp logic chính của bạn sạch sẽ và tập trung vào quá trình chuyển đổi. + +## Các Câu Hỏi Thường Gặp & Mẹo + +- **Can I use JSON instead of XML?** + Chắc chắn rồi. Thay `TemplateData` bằng một lớp phân tích JSON (Jackson’s `ObjectMapper` hoạt động tốt) và điều chỉnh phương thức `process` để đọc các cặp key/value từ một `Map`. + +- **What if my placeholders contain spaces or special characters** + (Nếu placeholder của bạn chứa dấu cách hoặc ký tự đặc biệt, hãy đảm bảo chúng được định dạng đúng trong XML/JSON và trong template; bạn có thể cần bao quanh chúng bằng dấu ngoặc kép hoặc xử lý chúng trước khi thay thế.) + +## Bạn Nên Học Gì Tiếp Theo? + +Các tutorial sau đây đề cập đến các chủ đề liên quan chặt chẽ, xây dựng trên các kỹ thuật đã được trình bày trong hướng dẫn này. Mỗi tài nguyên bao gồm các ví dụ mã hoàn chỉnh với giải thích từng bước, giúp bạn nắm vững các tính năng API bổ sung và khám phá các cách triển khai thay thế trong dự án của mình. + +- [Tải Tài Liệu HTML Từ Tệp trong Aspose.HTML cho Java](/html/english/java/creating-managing-html-documents/load-html-documents-from-file/) +- [Lưu Tài Liệu HTML trong Aspose.HTML cho Java](/html/english/java/saving-html-documents/save-html-document/) +- [Xử Lý Dữ Liệu và Quản Lý Luồng trong Aspose.HTML cho Java](/html/english/java/data-handling-stream-management/) + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file