diff --git a/content/arabic/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/arabic/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..0524da69 --- /dev/null +++ b/content/arabic/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,221 @@ +--- +date: '2026-02-08' +description: تعلم كيفية تمييز نتائج البحث في Java وكيفية فهرسة المستندات باستخدام + GroupDocs.Search للـ Java مع الفهرسة المتزامنة وغير المتزامنة. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: تمييز نتائج البحث في جافا – الفهرسة المتزامنة والغير متزامنة +type: docs +url: /ar/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +.# تسليط الضوء على نتائج البحث Java – الفهرسة المتزامنة والغير متزامنة + +عزّز تطبيقات Java الخاصة بك عن طريق **تسليط الضوء على نتائج البحث Java** باستخدام مكتبة GroupDocs.Search القوية. سواء كنت تتعامل مع عدد قليل من الملفات أو مستودع ضخم، فإن إتقان الفهرسة المتزامنة والغير متزامنة يتيح لك تقديم نتائج سريعة ودقيقة دون حجب خيوط التطبيق. + +## إجابات سريعة +- **ماذا يعني “تسليط الضوء على نتائج البحث Java”؟** يشير إلى عرض المصطلحات المتطابقة في نتائج البحث بإشارات بصرية (مثل وسوم HTML ``) حتى يتمكن المستخدمون من رؤية موضع الاستعلام في كل مستند. +- **متى يجب استخدام الفهرسة المتزامنة؟** للمجموعات الصغيرة إلى المتوسطة حيث يلزم توفر المستندات المضافة حديثًا فورًا. +- **متى تكون الفهرسة الغير متزامنة مفضلة؟** عند معالجة مجموعات مستندات كبيرة أو تشغيلها على خيط واجهة المستخدم حيث يجب الحفاظ على استجابة التطبيق. +- **هل أحتاج إلى ترخيص؟** نسخة تجريبية مجانية تكفي للتطوير؛ الترخيص الكامل يفتح الميزات المتقدمة ويزيل حدود الاستخدام. +- **ما نسخة Java المدعومة؟** Java 8 أو أحدث. + +## ما هو “تسليط الضوء على نتائج البحث Java”؟ +تسليط الضوء على نتائج البحث في Java يعني أخذ التطابقات الخام التي تُرجعها GroupDocs.Search وتغليف المصطلحات المتطابقة بـ HTML (أو أي تنسيق آخر) لتبرز عند عرضها في واجهة مستخدم أو صفحة ويب. هذا يحسن تجربة المستخدم من خلال إظهار السياق لكل نتيجة على الفور. + +## لماذا نستخدم GroupDocs.Search للـ Java؟ +توفر GroupDocs.Search محركًا عالي الأداء ولا يعتمد على اللغة يدعم: +- الفهرسة والبحث في الوقت الحقيقي +- المعالجة الغير متزامنة للأحمال الكبيرة +- تسليط الضوء المدمج على النتائج +- دعم متعدد اللغات ومحلل مخصص + +هذه القدرات تجعلها مثالية لأنظمة إدارة المحتوى، كتالوجات التجارة الإلكترونية، ومستودعات المستندات المؤسسية. + +## المتطلبات المسبقة +قبل البدء، تأكد من وجود ما يلي: + +- **مجموعة تطوير Java** (JDK 8 أو أحدث) مثبتة. +- بيئة تطوير متكاملة مثل **IntelliJ IDEA** أو **Eclipse**. +- مجلد يحتوي على المستندات التي تريد فهرستها. +- Maven لإدارة الاعتمادات (أو يمكنك تحميل ملف JAR يدويًا). + +### المكتبات والاعتمادات المطلوبة +أضف GroupDocs.Search إلى مشروع Maven الخاص بك: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +للتنزيلات المباشرة، احصل على أحدث نسخة من [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### إعداد البيئة +- تأكد أن **JAVA_HOME** يشير إلى JDK متوافق. +- أنشئ مشروعًا في بيئة التطوير وأضف تكوين Maven أعلاه. +- حضّر دليلًا (مثال: `documents/`) يحتوي على ملفات نصية، PDF، أو Word تجريبية. + +## كيفية إعداد GroupDocs.Search للـ Java +1. **تثبيت المكتبة** – استخدم المقتطف Maven أعلاه أو حمّل ملف JAR من [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **الحصول على ترخيص** – ابدأ بترخيص تجريبي، ثم قم بالترقية عندما تنتقل إلى بيئة الإنتاج. +3. **تهيئة الفهرس** – يوضح المقتطف التالي كيفية إنشاء (أو فتح) مجلد فهرس: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## كيفية تسليط الضوء على نتائج البحث Java – الفهرسة المتزامنة +تقوم الفهرسة المتزامنة بمعالجة المستندات فورًا، مما يجعل الملفات المضافة حديثًا قابلة للبحث على الفور. + +### الخطوة 1: إنشاء الفهرس وإرفاق معالجة الأخطاء +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### الخطوة 2: إضافة المستندات وتشغيل بحث +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### الخطوة 3: معالجة النتائج و**تسليط الضوء على نتائج البحث Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +يقوم `DocumentHighlighter` تلقائيًا بتغليف المصطلحات المتطابقة بوسوم `` (أو أي تنسيق تقوم بتكوينه)، مما يمنحك **نتائج بحث مُسلّطة** جاهزة للعرض. + +## كيفية تسليط الضوء على نتائج البحث Java – الفهرسة الغير متزامنة +عند التعامل مع آلاف الملفات، يصبح حجب الخيط الرئيسي غير مرغوب فيه. تسمح الفهرسة الغير متزامنة للمحرك بالعمل في الخلفية. + +### الخطوة 1: إعداد الفهرس مع مستمعي الأحداث +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### الخطوة 2: تفعيل الوضع الغير متزامن وبدء الفهرسة +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +أثناء بناء الفهرس، يمكن لتطبيقك الاستمرار في معالجة طلبات أخرى. بمجرد أن يُبلغ حدث `StatusChanged` عن `Ready`، يمكنك بأمان تشغيل عمليات البحث والحصول على **نتائج بحث مُسلّطة Java**. + +## كيفية **فهرسة المستندات java** – نصائح عملية +- **حجم الدفعة**: للمجموعات الضخمة، قسّم المجلد إلى دفعات أصغر لتجنب ارتفاع الذاكرة. +- **مرشحات الملفات**: استخدم `IndexingOptions.setFileExtensions` لتضمين الصيغ التي تحتاجها فقط (مثل `.pdf`، `.docx`). +- **إعادة الفهرسة**: عندما تتغير المستندات، استدعِ `index.update(documentPath)` بدلاً من إعادة بناء الفهرس بالكامل. + +## اعتبارات الأداء +- **الذاكرة**: راقب استهلاك الـ heap؛ زد قيمة `-Xmx` إذا كنت تعالج ملفات كبيرة كثيرة. +- **وحدة المعالجة**: الفهرسة الغير متزامنة توزع الحمل، لكنها لا تزال تستهلك CPU—راقبها باستخدام JVisualVM. +- **تسليط الضوء على النتائج**: يضيف التسليط عبئًا بسيطًا على المعالجة؛ احفظ HTML المُولّد في ذاكرة التخزين المؤقت إذا كنت تحتاج إلى عرض النتائج بشكل متكرر. + +## الأسئلة المتكررة + +**س: هل يمكنني دمج الفهرسة المتزامنة والغير متزامنة في نفس التطبيق؟** +ج: نعم. استخدم الفهرسة المتزامنة للمجموعات الصغيرة التي تُحدّث بشكل متكرر والفهرسة الغير متزامنة للاستيراد الضخم أو المهام الخلفية. + +**س: كيف يمكنني تخصيص نمط التسليط؟** +ج: قدم تنفيذًا مخصصًا لـ `DocumentHighlighter` يكتب وسوم HTML أو CSS أو XML المطلوبة حول المصطلحات المتطابقة. + +**س: ما أنواع الملفات التي يدعمها GroupDocs.Search بشكل افتراضي؟** +ج: نص، PDF، DOC/DOCX، XLS/XLSX، PPT/PPTX، HTML، والعديد غيرها عبر المحللات المدمجة. + +**س: هل يمكن البحث في عدة لغات في آنٍ واحد؟** +ج: بالتأكيد. يتضمن GroupDocs.Search محللات متعددة اللغات؛ ما عليك سوى تكوين الـ `Analyzer` المناسب عند إنشاء الفهرس. + +**س: كيف أؤمن مجلد الفهرس؟** +ج: احفظ الفهرس في دليل محمي، اضبط أذونات نظام الملفات بشكل صحيح، وفكّر في تشفير الفهرس باستخدام ميزات الأمان المتوفرة في المكتبة. + +--- + +**آخر تحديث:** 2026-02-08 +**تم الاختبار مع:** GroupDocs.Search 25.4 للـ Java +**المؤلف:** GroupDocs \ No newline at end of file diff --git a/content/chinese/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/chinese/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..8a3a6bbc --- /dev/null +++ b/content/chinese/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,234 @@ +--- +date: '2026-02-08' +description: 学习如何使用 GroupDocs.Search for Java 通过同步和异步索引实现 Java 搜索结果的高亮显示以及文档的索引。 +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Java 高亮搜索结果 – 同步与异步索引 +type: docs +url: /zh/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +**Author:** -> **作者：** GroupDocs + +Make sure to keep bold formatting. + +Now produce final markdown with translations. + +Check for any missing placeholders: CODE_BLOCK_0-6 all present. + +Check for any markdown links: only two links. Keep them. + +Check for images: none. + +All good. + +Now produce final answer.# 突出显示搜索结果 Java – 同步与异步索引 + +通过强大的 GroupDocs.Search 库 **highlighting search results Java** 来提升您的 Java 应用程序。无论是处理少量文件还是海量仓库，掌握同步和异步索引都能让您在不阻塞应用线程的情况下提供快速、准确的结果。 + +## 快速答案 +- **What does “highlight search results Java” mean?** 它指的是在搜索结果中使用可视化提示（例如 HTML `` 标签）来渲染匹配的词汇，以便用户能够看到查询在每个文档中的出现位置。 +- **When should I use synchronous indexing?** 对于需要新添加文档立即可用的小到中等规模数据集。 +- **When is asynchronous indexing preferable?** 在处理大型文档集合或在 UI 线程上运行时，需要保持应用响应性时，异步索引更为合适。 +- **Do I need a license?** 免费试用可用于开发；完整许可证解锁高级功能并取消使用限制。 +- **Which Java version is supported?** Java 8 或更高版本。 + +## 什么是 “highlight search results Java”？ +在 Java 中对搜索结果进行突出显示是指将 GroupDocs.Search 返回的原始匹配项用 HTML（或其他标记）包装，使其在 UI 或网页中显示时突出。这样可以通过即时展示每个命中的上下文来提升用户体验。 + +## 为什么在 Java 中使用 GroupDocs.Search？ +GroupDocs.Search 提供了一个高性能、语言无关的引擎，支持： +- 实时索引和搜索 +- 大规模工作负载的异步处理 +- 内置结果突出显示 +- 多语言和自定义分析器支持 + +这些功能使其非常适合内容管理系统、电子商务目录和企业文档库。 + +## 前提条件 +在开始之前，请确保您已经拥有： + +- **Java Development Kit**（JDK 8 或更高）已安装。 +- 如 **IntelliJ IDEA** 或 **Eclipse** 等 IDE。 +- 包含您想要索引的文档的文件夹。 +- 用于依赖管理的 Maven（或您也可以手动下载 JAR）。 + +### 必需的库和依赖 +将 GroupDocs.Search 添加到您的 Maven 项目中： + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +如需直接下载，请从 [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) 获取最新版本。 + +### 环境设置 +- 确认您的 **JAVA_HOME** 指向兼容的 JDK。 +- 在 IDE 中创建项目并添加上述 Maven 配置。 +- 准备一个目录（例如 `documents/`），其中包含示例文本、PDF 或 Word 文件。 + +## 如何在 Java 中设置 GroupDocs.Search +1. **Install the Library** – 使用上面的 Maven 代码段或从 [GroupDocs](https://releases.groupdocs.com/search/java/) 下载 JAR。 +2. **Obtain a License** – 首先使用试用许可证，随后在投入生产时升级。 +3. **Initialize the Index** – 以下代码片段展示了如何创建（或打开）索引文件夹： + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## 如何在 Java 中突出显示搜索结果 – 同步索引 +同步索引会立即处理文档，使新添加的文件能够即时搜索。 + +### 步骤 1：创建索引并附加错误处理 +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### 步骤 2：添加文档并执行搜索 +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### 步骤 3：处理结果并 **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +`DocumentHighlighter` 会自动使用 `` 标签（或您配置的任何格式）包装匹配的词汇，为您提供可直接显示的 **highlighted search results**。 + +## 如何在 Java 中突出显示搜索结果 – 异步索引 +在处理成千上万的文件时，阻塞主线程是不可取的。异步索引让引擎在后台工作。 + +### 步骤 1：使用事件监听器设置索引 +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### 步骤 2：启用异步模式并开始索引 +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +在索引构建期间，您的应用程序可以继续处理其他请求。一旦 `StatusChanged` 事件报告为 `Ready`，您即可安全地执行搜索并获取 **highlighted search results Java**。 + +## 如何 **index documents java** – 实用技巧 +- **Batch size**：对于巨大的集合，将文件夹拆分为更小的批次以避免内存峰值。 +- **File filters**：使用 `IndexingOptions.setFileExtensions` 仅包含所需的格式（例如 `.pdf`、`.docx`）。 +- **Re‑indexing**：文档更改时，调用 `index.update(documentPath)` 而不是重新构建整个索引。 + +## 性能考虑 +- **Memory**：关注堆内存使用情况；如果处理大量大文件，请增加 `-Xmx`。 +- **CPU**：异步索引分散工作负载，但仍会消耗 CPU——请使用 JVisualVM 进行监控。 +- **Result Highlighting**：突出显示会带来少量处理开销；如果需要重复显示结果，请缓存生成的 HTML。 + +## 常见问题 + +**Q: 我可以在同一个应用程序中同时使用同步和异步索引吗？** +**A:** 是的。对小型、频繁更新的集合使用同步索引，对批量导入或后台任务使用异步索引。 + +**Q: 我该如何自定义突出显示的样式？** +**A:** 提供自定义的 `DocumentHighlighter` 实现，在匹配词汇周围写入所需的 HTML、CSS 或 XML 标签。 + +**Q: GroupDocs.Search 开箱即支持哪些文件类型？** +**A:** 文本、PDF、DOC/DOCX、XLS/XLSX、PPT/PPTX、HTML 等众多格式，均通过其内置解析器支持。 + +**Q: 能否同时搜索多种语言？** +**A:** 当然可以。GroupDocs.Search 包含多语言分析器；在创建索引时只需配置相应的 `Analyzer`。 + +**Q: 我该如何保护索引文件夹的安全？** +**A:** 将索引存放在受保护的目录，设置合适的文件系统权限，并考虑使用库的安全功能对索引进行加密。 + +--- + +**最后更新：** 2026-02-08 +**测试环境：** GroupDocs.Search 25.4 for Java +**作者：** GroupDocs \ No newline at end of file diff --git a/content/czech/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/czech/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..567623fb --- /dev/null +++ b/content/czech/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,240 @@ +--- +date: '2026-02-08' +description: Naučte se, jak zvýraznit výsledky vyhledávání v Javě a jak indexovat + dokumenty v Javě pomocí GroupDocs.Search pro Javu se synchronním i asynchronním + indexováním. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Zvýraznění výsledků vyhledávání Java – synchronní a asynchronní indexování +type: docs +url: /cs/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + + items translate. + +## Frequently Asked Questions => "Často kladené otázky" + +Then Q&A translate. + +At end: + +**Last Updated:** 2026-02-08 => keep date. + +**Tested With:** GroupDocs.Search 25.4 for Java => translate label. + +**Author:** GroupDocs => translate label. + +Make sure not to translate URLs, code placeholders, file paths. + +Also keep markdown formatting. + +Let's produce final.# Highlight Search Results Java – Synchronous & Async Indexing + +Boost your Java applications by **highlighting search results Java** with the powerful GroupDocs.Search library. Whether you’re dealing with a few files or a massive repository, mastering both synchronous and asynchronous indexing lets you deliver fast, accurate results without blocking your application threads. + +## Quick Answers +- **What does “highlight search results Java” mean?** It refers to rendering matched terms in search results with visual cues (e.g., HTML `` tags) so users can see where the query appears in each document. +- **When should I use synchronous indexing?** For small to medium data sets where immediate availability of newly added documents is required. +- **When is asynchronous indexing preferable?** When processing large document collections or running on a UI thread where you must keep the application responsive. +- **Do I need a license?** A free trial works for development; a full license unlocks advanced features and removes usage limits. +- **Which Java version is supported?** Java 8 or later. + +## What is “highlight search results Java”? +Highlighting search results in Java means taking the raw matches returned by GroupDocs.Search and wrapping the matching terms in HTML (or another markup) so they stand out when displayed in a UI or web page. This improves user experience by instantly showing the context of each hit. + +## Why use GroupDocs.Search for Java? +GroupDocs.Search provides a high‑performance, language‑agnostic engine that supports: +- Real‑time indexing and searching +- Asynchronous processing for large workloads +- Built‑in result highlighting +- Multi‑language and custom analyzer support + +These capabilities make it ideal for content management systems, e‑commerce catalogs, and enterprise document repositories. + +## Prerequisites +Before you start, make sure you have: + +- **Java Development Kit** (JDK 8 or newer) installed. +- An IDE such as **IntelliJ IDEA** or **Eclipse**. +- A folder containing the documents you want to index. +- Maven for dependency management (or you can download the JAR manually). + +### Required Libraries and Dependencies +Add GroupDocs.Search to your Maven project: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +For direct downloads, get the latest version from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Environment Setup +- Verify your **JAVA_HOME** points to a compatible JDK. +- Create a project in your IDE and add the Maven configuration above. +- Prepare a directory (e.g., `documents/`) with sample text, PDF, or Word files. + +## How to set up GroupDocs.Search for Java +1. **Install the Library** – Use the Maven snippet above or download the JAR from [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Obtain a License** – Start with a trial license, then upgrade when you move to production. +3. **Initialize the Index** – The following snippet shows how to create (or open) an index folder: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## How to highlight search results Java – Synchronous Indexing +Synchronous indexing processes documents immediately, making newly added files searchable right away. + +### Step 1: Create the index and attach error handling +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Step 2: Add documents and run a search +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Step 3: Process results and **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +The `DocumentHighlighter` automatically wraps matched terms with `` tags (or any format you configure), giving you **highlighted search results** ready for display. + +## How to highlight search results Java – Asynchronous Indexing +When dealing with thousands of files, blocking the main thread is undesirable. Asynchronous indexing lets the engine work in the background. + +### Step 1: Set up the index with event listeners +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Step 2: Enable asynchronous mode and start indexing +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +While the index is being built, your application can continue to serve other requests. Once the `StatusChanged` event reports `Ready`, you can safely run searches and obtain **highlighted search results Java**. + +## How to **index documents java** – Practical Tips +- **Batch size**: For huge collections, split the folder into smaller batches to avoid memory spikes. +- **File filters**: Use `IndexingOptions.setFileExtensions` to include only the formats you need (e.g., `.pdf`, `.docx`). +- **Re‑indexing**: When documents change, call `index.update(documentPath)` instead of rebuilding the whole index. + +## Performance Considerations +- **Memory**: Keep an eye on heap usage; increase `-Xmx` if you process many large files. +- **CPU**: Asynchronous indexing spreads the workload, but still consumes CPU—monitor with JVisualVM. +- **Result Highlighting**: Highlighting adds a small processing overhead; cache the generated HTML if you need to display results repeatedly. + +## Frequently Asked Questions + +**Q: Can I combine synchronous and asynchronous indexing in the same application?** +A: Yes. Use synchronous indexing for small, frequently updated sets and asynchronous indexing for bulk imports or background jobs. + +**Q: How do I customize the highlight style?** +A: Provide a custom `DocumentHighlighter` implementation that writes the desired HTML, CSS, or XML tags around matched terms. + +**Q: What file types does GroupDocs.Search support out of the box?** +A: Text, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML, and many more via its built‑in parsers. + +**Q: Is it possible to search in multiple languages simultaneously?** +A: Absolutely. GroupDocs.Search includes multi‑language analyzers; just configure the appropriate `Analyzer` when creating the index. + +**Q: How do I secure the index folder?** +A: Store the index in a protected directory, set proper file system permissions, and consider encrypting the index with the library’s security features. + +--- + +**Last Updated:** 2026-02-08 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs \ No newline at end of file diff --git a/content/dutch/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/dutch/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..7d117872 --- /dev/null +++ b/content/dutch/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,222 @@ +--- +date: '2026-02-08' +description: Leer hoe u zoekresultaten in Java kunt markeren en hoe u documenten in + Java kunt indexeren met GroupDocs.Search voor Java, met zowel synchrone als asynchrone + indexering. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Markeer zoekresultaten Java – Synchrone & Asynchrone indexering +type: docs +url: /nl/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Markeer zoekresultaten Java – Synchronous & Async Indexing + +Boost your Java applications by **highlighting search results Java** with the powerful GroupDocs.Search library. Whether you’re dealing with a few files or a massive repository, mastering both synchronous and asynchronous indexing lets you deliver fast, accurate results without blocking your application threads. + +## Snelle antwoorden +- **Wat betekent “highlight search results Java”?** Het verwijst naar het weergeven van overeenkomende termen in zoekresultaten met visuele aanwijzingen (bijv. HTML ``‑tags) zodat gebruikers kunnen zien waar de zoekopdracht in elk document voorkomt. +- **Wanneer moet ik synchronous indexing gebruiken?** Voor kleine tot middelgrote datasets waarbij directe beschikbaarheid van nieuw toegevoegde documenten vereist is. +- **Wanneer is asynchronous indexing beter?** Bij het verwerken van grote documentverzamelingen of wanneer je op een UI‑thread werkt en de applicatie responsief moet blijven. +- **Heb ik een licentie nodig?** Een gratis proefversie werkt voor ontwikkeling; een volledige licentie ontgrendelt geavanceerde functies en verwijdert gebruikslimieten. +- **Welke Java‑versie wordt ondersteund?** Java 8 of later. + +## Wat is “highlight search results Java”? +Highlighting search results in Java means taking the raw matches returned by GroupDocs.Search and wrapping the matching terms in HTML (or another markup) so they stand out when displayed in a UI or web page. This improves user experience by instantly showing the context of each hit. + +## Waarom GroupDocs.Search voor Java gebruiken? +GroupDocs.Search provides a high‑performance, language‑agnostic engine that supports: +- Real‑time indexing and searching +- Asynchronous processing for large workloads +- Built‑in result highlighting +- Multi‑language and custom analyzer support + +These capabilities make it ideal for content management systems, e‑commerce catalogs, and enterprise document repositories. + +## Vereisten +Before you start, make sure you have: + +- **Java Development Kit** (JDK 8 or newer) installed. +- An IDE such as **IntelliJ IDEA** or **Eclipse**. +- A folder containing the documents you want to index. +- Maven for dependency management (or you can download the JAR manually). + +### Vereiste bibliotheken en afhankelijkheden +Add GroupDocs.Search to your Maven project: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +For direct downloads, get the latest version from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Omgevingsconfiguratie +- Verify your **JAVA_HOME** points to a compatible JDK. +- Create a project in your IDE and add the Maven configuration above. +- Prepare a directory (e.g., `documents/`) with sample text, PDF, or Word files. + +## Hoe GroupDocs.Search voor Java in te stellen +1. **Install the Library** – Use the Maven snippet above or download the JAR from [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Obtain a License** – Start with a trial license, then upgrade when you move to production. +3. **Initialize the Index** – The following snippet shows how to create (or open) an index folder: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## Hoe highlight search results Java – Synchronous Indexing +Synchronous indexing processes documents immediately, making newly added files searchable right away. + +### Stap 1: Maak de index aan en voeg foutafhandeling toe +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Stap 2: Voeg documenten toe en voer een zoekopdracht uit +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Stap 3: Verwerk resultaten en **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +The `DocumentHighlighter` automatically wraps matched terms with `` tags (or any format you configure), giving you **highlighted search results** ready for display. + +## Hoe highlight search results Java – Asynchronous Indexing +When dealing with thousands of files, blocking the main thread is undesirable. Asynchronous indexing lets the engine work in the background. + +### Stap 1: Stel de index in met event listeners +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Stap 2: Schakel asynchrone modus in en start indexering +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +While the index is being built, your application can continue to serve other requests. Once the `StatusChanged` event reports `Ready`, you can safely run searches and obtain **highlighted search results Java**. + +## Hoe **index documents java** – Praktische tips +- **Batch size**: For huge collections, split the folder into smaller batches to avoid memory spikes. +- **File filters**: Use `IndexingOptions.setFileExtensions` to include only the formats you need (e.g., `.pdf`, `.docx`). +- **Re‑indexing**: When documents change, call `index.update(documentPath)` instead of rebuilding the whole index. + +## Prestatieoverwegingen +- **Memory**: Keep an eye on heap usage; increase `-Xmx` if you process many large files. +- **CPU**: Asynchronous indexing spreads the workload, but still consumes CPU—monitor with JVisualVM. +- **Result Highlighting**: Highlighting adds a small processing overhead; cache the generated HTML if you need to display results repeatedly. + +## Veelgestelde vragen + +**Q: Kan ik synchronous en asynchronous indexing combineren in dezelfde applicatie?** +A: Ja. Gebruik synchronous indexing voor kleine, vaak bijgewerkte sets en asynchronous indexing voor bulk‑imports of achtergrondtaken. + +**Q: Hoe pas ik de highlight‑stijl aan?** +A: Provide a custom `DocumentHighlighter` implementation that writes the desired HTML, CSS, or XML tags around matched terms. + +**Q: Welke bestandstypen ondersteunt GroupDocs.Search out of the box?** +A: Text, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML, and many more via its built‑in parsers. + +**Q: Is het mogelijk om tegelijk in meerdere talen te zoeken?** +A: Absolutely. GroupDocs.Search includes multi‑language analyzers; just configure the appropriate `Analyzer` when creating the index. + +**Q: Hoe beveilig ik de indexmap?** +A: Store the index in a protected directory, set proper file system permissions, and consider encrypting the index with the library’s security features. + +--- + +**Last Updated:** 2026-02-08 +**Tested With:** GroupDocs.Search 25.4 for Java +**Auteur:** GroupDocs \ No newline at end of file diff --git a/content/english/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/english/java/searching/master-groupdocs-search-java-document-indexing/_index.md index 00eed4cf..0e001435 100644 --- a/content/english/java/searching/master-groupdocs-search-java-document-indexing/_index.md +++ b/content/english/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -1,7 +1,7 @@ --- -title: "Mastering Document Search in Java: Synchronous and Asynchronous Indexing with GroupDocs.Search" -description: "Enhance your Java applications by mastering document search with synchronous and asynchronous indexing using GroupDocs.Search for Java. Learn setup, implementation, and optimization techniques." -date: "2025-05-20" +title: "Highlight Search Results Java – Synchronous & Async Indexing" +description: "Learn how to highlight search results Java and how to index documents java using GroupDocs.Search for Java with synchronous and asynchronous indexing." +date: "2026-02-08" weight: 1 url: "/java/searching/master-groupdocs-search-java-document-indexing/" keywords: @@ -10,18 +10,41 @@ keywords: - asynchronous indexing type: docs --- -# Mastering Document Search in Java: Implementing Synchronous and Asynchronous Indexing with GroupDocs.Search -## Introduction -Are you looking to enhance your Java applications with powerful document search capabilities? Whether it's managing vast repositories of text files or delivering precise query results, efficient indexing is essential. This tutorial delves into implementing both synchronous and asynchronous indexing using **GroupDocs.Search for Java**, a robust library designed for high-performance search functionalities. -In this guide, you'll learn how to: -- Set up GroupDocs.Search in your Java environment -- Implement synchronous indexing for real-time document processing -- Use asynchronous indexing to handle large datasets without blocking application threads -Let's start by exploring the prerequisites needed for this setup. + +# Highlight Search Results Java – Synchronous & Async Indexing + +Boost your Java applications by **highlighting search results Java** with the powerful GroupDocs.Search library. Whether you’re dealing with a few files or a massive repository, mastering both synchronous and asynchronous indexing lets you deliver fast, accurate results without blocking your application threads. + +## Quick Answers +- **What does “highlight search results Java” mean?** It refers to rendering matched terms in search results with visual cues (e.g., HTML `` tags) so users can see where the query appears in each document. +- **When should I use synchronous indexing?** For small to medium data sets where immediate availability of newly added documents is required. +- **When is asynchronous indexing preferable?** When processing large document collections or running on a UI thread where you must keep the application responsive. +- **Do I need a license?** A free trial works for development; a full license unlocks advanced features and removes usage limits. +- **Which Java version is supported?** Java 8 or later. + +## What is “highlight search results Java”? +Highlighting search results in Java means taking the raw matches returned by GroupDocs.Search and wrapping the matching terms in HTML (or another markup) so they stand out when displayed in a UI or web page. This improves user experience by instantly showing the context of each hit. + +## Why use GroupDocs.Search for Java? +GroupDocs.Search provides a high‑performance, language‑agnostic engine that supports: +- Real‑time indexing and searching +- Asynchronous processing for large workloads +- Built‑in result highlighting +- Multi‑language and custom analyzer support + +These capabilities make it ideal for content management systems, e‑commerce catalogs, and enterprise document repositories. + ## Prerequisites -Before diving into the code, ensure you have the following requirements met: +Before you start, make sure you have: + +- **Java Development Kit** (JDK 8 or newer) installed. +- An IDE such as **IntelliJ IDEA** or **Eclipse**. +- A folder containing the documents you want to index. +- Maven for dependency management (or you can download the JAR manually). + ### Required Libraries and Dependencies -To use GroupDocs.Search in your Java project, include it as a dependency. If you're using Maven, add the following configuration to your `pom.xml` file: +Add GroupDocs.Search to your Maven project: + ```xml @@ -39,36 +62,30 @@ To use GroupDocs.Search in your Java project, include it as a dependency. If you ``` + For direct downloads, get the latest version from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + ### Environment Setup -Ensure you have: -- A compatible JDK installed (Java 8 or later) -- An IDE like IntelliJ IDEA or Eclipse configured for Java development -- Access to a directory containing documents for indexing -### Knowledge Prerequisites -This tutorial assumes familiarity with: -- Basic Java programming concepts -- Handling file input/output operations in Java -- Using Maven for dependency management -## Setting Up GroupDocs.Search for Java -To begin using GroupDocs.Search, follow these setup steps: -1. **Install the Library**: Add GroupDocs.Search as a dependency via Maven or download it directly from [GroupDocs](https://releases.groupdocs.com/search/java/). -2. **License Acquisition**: Start with a free trial, obtain a temporary license, or purchase a full license to unlock advanced features. -3. **Basic Initialization**: - ```java - import com.groupdocs.search.Index; - - // Create an index in the specified folder - Index index = new Index("path/to/index/folder"); - ``` -## Implementation Guide -### Synchronous Indexing Feature -Synchronous indexing allows you to add documents and process search queries in real-time. This section guides you through creating an index and adding documents synchronously. -#### Overview -This feature is ideal for applications requiring immediate results, such as small datasets or when low latency is critical. -#### Implementation Steps -**1. Set Up Index and Event Handling** -Create a new index or open an existing one. Subscribe to events for error handling: +- Verify your **JAVA_HOME** points to a compatible JDK. +- Create a project in your IDE and add the Maven configuration above. +- Prepare a directory (e.g., `documents/`) with sample text, PDF, or Word files. + +## How to set up GroupDocs.Search for Java +1. **Install the Library** – Use the Maven snippet above or download the JAR from [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Obtain a License** – Start with a trial license, then upgrade when you move to production. +3. **Initialize the Index** – The following snippet shows how to create (or open) an index folder: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## How to highlight search results Java – Synchronous Indexing +Synchronous indexing processes documents immediately, making newly added files searchable right away. + +### Step 1: Create the index and attach error handling ```java import com.groupdocs.search.*; import com.groupdocs.search.events.*; @@ -89,8 +106,8 @@ public class SynchronousIndexingFeature { } }); ``` -**2. Add Documents to the Index** -Add documents synchronously and perform a search: + +### Step 2: Add documents and run a search ```java // Add documents index.add(documentsFolder); @@ -99,8 +116,8 @@ Add documents synchronously and perform a search: String query = "tincidunt"; SearchResult result = index.search(query); ``` -**3. Process Search Results** -Iterate over results and highlight them in HTML format: + +### Step 3: Process results and **highlight search results Java** ```java for (int i = 0; i < result.getDocumentCount(); i++) { FoundDocument document = result.getFoundDocument(i); @@ -119,13 +136,13 @@ Iterate over results and highlight them in HTML format: } } ``` -### Asynchronous Indexing Feature -Asynchronous indexing is suitable for large datasets where non-blocking operations are crucial. -#### Overview -This feature allows you to add documents without interrupting the main application thread, improving performance and responsiveness. -#### Implementation Steps -**1. Set Up Index and Event Handling** -Create an index and subscribe to status changes: + +The `DocumentHighlighter` automatically wraps matched terms with `` tags (or any format you configure), giving you **highlighted search results** ready for display. + +## How to highlight search results Java – Asynchronous Indexing +When dealing with thousands of files, blocking the main thread is undesirable. Asynchronous indexing lets the engine work in the background. + +### Step 1: Set up the index with event listeners ```java import com.groupdocs.search.*; import com.groupdocs.search.events.*; @@ -154,8 +171,8 @@ public class AsynchronousIndexingFeature { } }); ``` -**2. Configure Asynchronous Options** -Set up options for asynchronous indexing: + +### Step 2: Enable asynchronous mode and start indexing ```java // Set up async indexing options IndexingOptions options = new IndexingOptions(); @@ -166,16 +183,38 @@ Set up options for asynchronous indexing: } } ``` -## Practical Applications -GroupDocs.Search can be integrated into various systems for enhanced search capabilities: -1. **Content Management Systems**: Improve document retrieval and search functionalities. -2. **E-commerce Platforms**: Enable product searches across extensive catalogs. -3. **Enterprise Document Repositories**: Facilitate efficient data management and compliance. + +While the index is being built, your application can continue to serve other requests. Once the `StatusChanged` event reports `Ready`, you can safely run searches and obtain **highlighted search results Java**. + +## How to **index documents java** – Practical Tips +- **Batch size**: For huge collections, split the folder into smaller batches to avoid memory spikes. +- **File filters**: Use `IndexingOptions.setFileExtensions` to include only the formats you need (e.g., `.pdf`, `.docx`). +- **Re‑indexing**: When documents change, call `index.update(documentPath)` instead of rebuilding the whole index. + ## Performance Considerations -To optimize performance with GroupDocs.Search: -- Monitor resource usage to ensure smooth operation. -- Utilize asynchronous indexing for large datasets to prevent application slowdowns. -- Follow Java memory management best practices, such as managing heap size and garbage collection effectively. -## Conclusion -By implementing synchronous and asynchronous indexing with GroupDocs.Search in Java, you can significantly enhance your document search capabilities. Whether dealing with small or extensive datasets, these techniques provide flexibility and efficiency. -To further explore GroupDocs.Search, consider experimenting with advanced features like custom analyzers and multi-language support. +- **Memory**: Keep an eye on heap usage; increase `-Xmx` if you process many large files. +- **CPU**: Asynchronous indexing spreads the workload, but still consumes CPU—monitor with JVisualVM. +- **Result Highlighting**: Highlighting adds a small processing overhead; cache the generated HTML if you need to display results repeatedly. + +## Frequently Asked Questions + +**Q: Can I combine synchronous and asynchronous indexing in the same application?** +A: Yes. Use synchronous indexing for small, frequently updated sets and asynchronous indexing for bulk imports or background jobs. + +**Q: How do I customize the highlight style?** +A: Provide a custom `DocumentHighlighter` implementation that writes the desired HTML, CSS, or XML tags around matched terms. + +**Q: What file types does GroupDocs.Search support out of the box?** +A: Text, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML, and many more via its built‑in parsers. + +**Q: Is it possible to search in multiple languages simultaneously?** +A: Absolutely. GroupDocs.Search includes multi‑language analyzers; just configure the appropriate `Analyzer` when creating the index. + +**Q: How do I secure the index folder?** +A: Store the index in a protected directory, set proper file system permissions, and consider encrypting the index with the library’s security features. + +--- + +**Last Updated:** 2026-02-08 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs \ No newline at end of file diff --git a/content/french/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/french/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..29d96f5c --- /dev/null +++ b/content/french/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,223 @@ +--- +date: '2026-02-08' +description: Apprenez à mettre en surbrillance les résultats de recherche Java et + à indexer des documents Java à l'aide de GroupDocs.Search for Java avec une indexation + synchrone et asynchrone. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Mise en évidence des résultats de recherche Java – Indexation synchrone et + asynchrone +type: docs +url: /fr/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + + content.# Mise en évidence des résultats de recherche Java – Indexation synchrone et asynchrone + +Boostez vos applications Java en **mise en évidence des résultats de recherche Java** avec la puissante bibliothèque GroupDocs.Search. Que vous manipuliez quelques fichiers ou un référentiel massif, maîtriser à la fois l'indexation synchrone et asynchrone vous permet de fournir des résultats rapides et précis sans bloquer les threads de votre application. + +## Réponses rapides +- **Que signifie « mise en évidence des résultats de recherche Java » ?** Il s'agit de rendre les termes correspondants dans les résultats de recherche avec des repères visuels (par ex., les balises HTML ``) afin que les utilisateurs puissent voir où la requête apparaît dans chaque document. +- **Quand devrais-je utiliser l'indexation synchrone ?** Pour des ensembles de données petits à moyens où la disponibilité immédiate des documents nouvellement ajoutés est requise. +- **Quand l'indexation asynchrone est-elle préférable ?** Lors du traitement de grandes collections de documents ou lors de l'exécution sur un thread UI où il faut garder l'application réactive. +- **Ai-je besoin d'une licence ?** Un essai gratuit suffit pour le développement ; une licence complète débloque les fonctionnalités avancées et supprime les limites d'utilisation. +- **Quelle version de Java est prise en charge ?** Java 8 ou plus récent. + +## Qu'est-ce que la « mise en évidence des résultats de recherche Java » ? +La mise en évidence des résultats de recherche en Java consiste à prendre les correspondances brutes renvoyées par GroupDocs.Search et à entourer les termes correspondants avec du HTML (ou un autre balisage) afin qu'ils se démarquent lorsqu'ils sont affichés dans une interface ou une page web. Cela améliore l'expérience utilisateur en affichant instantanément le contexte de chaque résultat. + +## Pourquoi utiliser GroupDocs.Search pour Java ? +GroupDocs.Search fournit un moteur haute performance, indépendant du langage, qui prend en charge : +- Indexation et recherche en temps réel +- Traitement asynchrone pour de lourdes charges de travail +- Mise en évidence des résultats intégrée +- Prise en charge multilingue et d'analyseurs personnalisés + +Ces capacités le rendent idéal pour les systèmes de gestion de contenu, les catalogues e‑commerce et les dépôts de documents d'entreprise. + +## Prérequis +Avant de commencer, assurez‑vous d'avoir : + +- **Java Development Kit** (JDK 8 ou plus récent) installé. +- Un IDE tel que **IntelliJ IDEA** ou **Eclipse**. +- Un dossier contenant les documents que vous souhaitez indexer. +- Maven pour la gestion des dépendances (ou vous pouvez télécharger le JAR manuellement). + +### Bibliothèques et dépendances requises +Ajoutez GroupDocs.Search à votre projet Maven : + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Pour les téléchargements directs, obtenez la dernière version depuis [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Configuration de l'environnement +- Vérifiez que votre **JAVA_HOME** pointe vers un JDK compatible. +- Créez un projet dans votre IDE et ajoutez la configuration Maven ci‑dessus. +- Préparez un répertoire (par ex., `documents/`) contenant des fichiers texte, PDF ou Word d'exemple. + +## Comment configurer GroupDocs.Search pour Java +1. **Installer la bibliothèque** – Utilisez le fragment Maven ci‑dessus ou téléchargez le JAR depuis [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Obtenir une licence** – Commencez avec une licence d'essai, puis passez à une licence complète lorsque vous passez en production. +3. **Initialiser l'index** – Le fragment suivant montre comment créer (ou ouvrir) un dossier d'index : + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## Comment mettre en évidence les résultats de recherche Java – Indexation synchrone +L'indexation synchrone traite les documents immédiatement, rendant les fichiers nouvellement ajoutés recherchables dès que possible. + +### Étape 1 : Créer l'index et ajouter la gestion des erreurs +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Étape 2 : Ajouter des documents et lancer une recherche +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Étape 3 : Traiter les résultats et **mise en évidence des résultats de recherche Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +Le `DocumentHighlighter` entoure automatiquement les termes correspondants avec des balises `` (ou tout autre format que vous configurez), vous fournissant des **résultats de recherche mis en évidence** prêts à être affichés. + +## Comment mettre en évidence les résultats de recherche Java – Indexation asynchrone +Lorsque vous traitez des milliers de fichiers, bloquer le thread principal est indésirable. L'indexation asynchrone permet au moteur de travailler en arrière‑plan. + +### Étape 1 : Configurer l'index avec des écouteurs d'événements +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Étape 2 : Activer le mode asynchrone et démarrer l'indexation +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +Pendant que l'index est en cours de construction, votre application peut continuer à traiter d'autres requêtes. Une fois que l'événement `StatusChanged` indique `Ready`, vous pouvez lancer des recherches en toute sécurité et obtenir des **résultats de recherche mis en évidence Java**. + +## Comment **indexer des documents java** – Conseils pratiques +- **Taille de lot** : pour d'énormes collections, divisez le dossier en lots plus petits afin d'éviter les pics de mémoire. +- **Filtres de fichiers** : utilisez `IndexingOptions.setFileExtensions` pour n'inclure que les formats nécessaires (par ex., `.pdf`, `.docx`). +- **Ré‑indexation** : lorsque les documents changent, appelez `index.update(documentPath)` au lieu de reconstruire l'intégralité de l'index. + +## Considérations de performance +- **Mémoire** : surveillez l'utilisation du tas ; augmentez `-Xmx` si vous traitez de nombreux fichiers volumineux. +- **CPU** : l'indexation asynchrone répartit la charge, mais consomme toujours du CPU—surveillez avec JVisualVM. +- **Mise en évidence des résultats** : la mise en évidence ajoute une petite surcharge de traitement ; mettez en cache le HTML généré si vous devez afficher les résultats de façon répétée. + +## Foire aux questions + +**Q : Puis‑je combiner l'indexation synchrone et asynchrone dans la même application ?** +R : Oui. Utilisez l'indexation synchrone pour les petits ensembles fréquemment mis à jour et l'indexation asynchrone pour les importations massives ou les tâches en arrière‑plan. + +**Q : Comment personnaliser le style de mise en évidence ?** +R : Fournissez une implémentation personnalisée de `DocumentHighlighter` qui écrit les balises HTML, CSS ou XML souhaitées autour des termes correspondants. + +**Q : Quels types de fichiers GroupDocs.Search prend‑il en charge nativement ?** +R : Texte, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML, et bien d’autres via ses analyseurs intégrés. + +**Q : Est‑il possible de rechercher dans plusieurs langues simultanément ?** +R : Absolument. GroupDocs.Search inclut des analyseurs multilingues ; il suffit de configurer l'`Analyzer` approprié lors de la création de l'index. + +**Q : Comment sécuriser le dossier d'index ?** +R : Stockez l'index dans un répertoire protégé, définissez les permissions système appropriées et envisagez de chiffrer l'index avec les fonctionnalités de sécurité de la bibliothèque. + +--- + +**Dernière mise à jour :** 2026-02-08 +**Testé avec :** GroupDocs.Search 25.4 for Java +**Auteur :** GroupDocs \ No newline at end of file diff --git a/content/german/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/german/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..5b3f3b7c --- /dev/null +++ b/content/german/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,222 @@ +--- +date: '2026-02-08' +description: Erfahren Sie, wie Sie Suchergebnisse in Java hervorheben und wie Sie + Dokumente in Java mit GroupDocs.Search für Java mittels synchroner und asynchroner + Indizierung indexieren. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Hervorhebung von Suchergebnissen Java – Synchrone & asynchrone Indexierung +type: docs +url: /de/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Highlight Search Results Java – Synchronous & Async Indexing + +Boost your Java applications by **highlighting search results Java** with the powerful GroupDocs.Search library. Whether you’re dealing with a few files or a massive repository, mastering both synchronous and asynchronous indexing lets you deliver fast, accurate results without blocking your application threads. + +## Quick Answers +- **What does “highlight search results Java” mean?** It refers to rendering matched terms in search results with visual cues (e.g., HTML `` tags) so users can see where the query appears in each document. +- **When should I use synchronous indexing?** For small to medium data sets where immediate availability of newly added documents is required. +- **When is asynchronous indexing preferable?** When processing large document collections or running on a UI thread where you must keep the application responsive. +- **Do I need a license?** A free trial works for development; a full license unlocks advanced features and removes usage limits. +- **Which Java version is supported?** Java 8 or later. + +## What is “highlight search results Java”? +Highlighting search results in Java means taking the raw matches returned by GroupDocs.Search and wrapping the matching terms in HTML (or another markup) so they stand out when displayed in a UI or web page. This improves user experience by instantly showing the context of each hit. + +## Why use GroupDocs.Search for Java? +GroupDocs.Search provides a high‑performance, language‑agnostic engine that supports: +- Real‑time indexing and searching +- Asynchronous processing for large workloads +- Built‑in result highlighting +- Multi‑language and custom analyzer support + +These capabilities make it ideal for content management systems, e‑commerce catalogs, and enterprise document repositories. + +## Prerequisites +Before you start, make sure you have: + +- **Java Development Kit** (JDK 8 or newer) installed. +- An IDE such as **IntelliJ IDEA** or **Eclipse**. +- A folder containing the documents you want to index. +- Maven for dependency management (or you can download the JAR manually). + +### Required Libraries and Dependencies +Add GroupDocs.Search to your Maven project: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +For direct downloads, get the latest version from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Environment Setup +- Verify your **JAVA_HOME** points to a compatible JDK. +- Create a project in your IDE and add the Maven configuration above. +- Prepare a directory (e.g., `documents/`) with sample text, PDF, or Word files. + +## How to set up GroupDocs.Search for Java +1. **Install the Library** – Use the Maven snippet above or download the JAR from [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Obtain a License** – Start with a trial license, then upgrade when you move to production. +3. **Initialize the Index** – The following snippet shows how to create (or open) an index folder: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## How to highlight search results Java – Synchronous Indexing +Synchronous indexing processes documents immediately, making newly added files searchable right away. + +### Step 1: Create the index and attach error handling +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Step 2: Add documents and run a search +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Step 3: Process results and **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +The `DocumentHighlighter` automatically wraps matched terms with `` tags (or any format you configure), giving you **highlighted search results** ready for display. + +## How to highlight search results Java – Asynchronous Indexing +When dealing with thousands of files, blocking the main thread is undesirable. Asynchronous indexing lets the engine work in the background. + +### Step 1: Set up the index with event listeners +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Step 2: Enable asynchronous mode and start indexing +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +While the index is being built, your application can continue to serve other requests. Once the `StatusChanged` event reports `Ready`, you can safely run searches and obtain **highlighted search results Java**. + +## How to **index documents java** – Practical Tips +- **Batch size**: For huge collections, split the folder into smaller batches to avoid memory spikes. +- **File filters**: Use `IndexingOptions.setFileExtensions` to include only the formats you need (e.g., `.pdf`, `.docx`). +- **Re‑indexing**: When documents change, call `index.update(documentPath)` instead of rebuilding the whole index. + +## Performance Considerations +- **Memory**: Keep an eye on heap usage; increase `-Xmx` if you process many large files. +- **CPU**: Asynchronous indexing spreads the workload, but still consumes CPU—monitor with JVisualVM. +- **Result Highlighting**: Highlighting adds a small processing overhead; cache the generated HTML if you need to display results repeatedly. + +## Frequently Asked Questions + +**Q: Can I combine synchronous and asynchronous indexing in the same application?** +A: Yes. Use synchronous indexing for small, frequently updated sets and asynchronous indexing for bulk imports or background jobs. + +**Q: How do I customize the highlight style?** +A: Provide a custom `DocumentHighlighter` implementation that writes the desired HTML, CSS, or XML tags around matched terms. + +**Q: What file types does GroupDocs.Search support out of the box?** +A: Text, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML, and many more via its built‑in parsers. + +**Q: Is it possible to search in multiple languages simultaneously?** +A: Absolutely. GroupDocs.Search includes multi‑language analyzers; just configure the appropriate `Analyzer` when creating the index. + +**Q: How do I secure the index folder?** +A: Store the index in a protected directory, set proper file system permissions, and consider encrypting the index with the library’s security features. + +--- + +**Last Updated:** 2026-02-08 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs \ No newline at end of file diff --git a/content/greek/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/greek/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..e698c113 --- /dev/null +++ b/content/greek/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,222 @@ +--- +date: '2026-02-08' +description: Μάθετε πώς να επισημαίνετε τα αποτελέσματα αναζήτησης Java και πώς να + ευρετηριάτε έγγραφα Java χρησιμοποιώντας το GroupDocs.Search for Java με συγχρονισμένη + και ασύγχρονη ευρετηρίαση. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Επισήμανση Αποτελεσμάτων Αναζήτησης Java – Συγχρονιστική & Ασύγχρονη Δεικτοδότηση +type: docs +url: /el/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Επισήμανση Αποτελεσμάτων Αναζήτησης Java – Συγχρονιστική & Ασύγχρονη Δεικτοδότηση + +Boost your Java applications by **highlighting search results Java** with the powerful GroupDocs.Search library. Whether you’re dealing with a few files or a massive repository, mastering both synchronous and asynchronous indexing lets you deliver fast, accurate results without blocking your application threads. + +## Γρήγορες Απαντήσεις +- **Τι σημαίνει “highlight search results Java”;** Αναφέρεται στην απόδοση των ταιριασμένων όρων στα αποτελέσματα αναζήτησης με οπτικές ενδείξεις (π.χ., ετικέτες HTML ``) ώστε οι χρήστες να βλέπουν πού εμφανίζεται το ερώτημα σε κάθε έγγραφο. +- **Πότε πρέπει να χρησιμοποιήσω συγχρονιστική δεικτοδότηση;** Για μικρά έως μεσαία σύνολα δεδομένων όπου απαιτείται άμεση διαθεσιμότητα των νεοπροστέθειων εγγράφων. +- **Πότε είναι προτιμότερη η ασύγχρονη δεικτοδότηση;** Όταν επεξεργάζεστε μεγάλες συλλογές εγγράφων ή εκτελείτε σε νήμα UI όπου πρέπει να διατηρείται η ανταπόκριση της εφαρμογής. +- **Χρειάζομαι άδεια;** Μια δωρεάν δοκιμή λειτουργεί για ανάπτυξη· μια πλήρης άδεια ξεκλειδώνει προηγμένες λειτουργίες και αφαιρεί τους περιορισμούς χρήσης. +- **Ποια έκδοση της Java υποστηρίζεται;** Java 8 ή νεότερη. + +## Τι είναι το “highlight search results Java”; +Η επισήμανση αποτελεσμάτων αναζήτησης σε Java σημαίνει ότι λαμβάνονται οι ακατέργαστες αντιστοιχίες που επιστρέφει το GroupDocs.Search και τυλίγονται οι ταιριασμένοι όροι σε HTML (ή άλλη σήμανση) ώστε να ξεχωρίζουν όταν εμφανίζονται σε UI ή ιστοσελίδα. Αυτό βελτιώνει την εμπειρία του χρήστη εμφανίζοντας άμεσα το πλαίσιο κάθε αποτελέσματος. + +## Γιατί να χρησιμοποιήσετε το GroupDocs.Search για Java; +GroupDocs.Search provides a high‑performance, language‑agnostic engine that supports: +- Δεικτοδότηση και αναζήτηση σε πραγματικό χρόνο +- Ασύγχρονη επεξεργασία για μεγάλα φορτία εργασίας +- Ενσωματωμένη επισήμανση αποτελεσμάτων +- Υποστήριξη πολυγλωσσικών και προσαρμοσμένων αναλυτών + +These capabilities make it ideal for content management systems, e‑commerce catalogs, and enterprise document repositories. + +## Προαπαιτούμενα +Before you start, make sure you have: + +- **Java Development Kit** (JDK 8 ή νεότερο) installed. +- Ένα IDE όπως το **IntelliJ IDEA** ή το **Eclipse**. +- Έναν φάκελο που περιέχει τα έγγραφα που θέλετε να δεικτοδοτήσετε. +- Maven για διαχείριση εξαρτήσεων (ή μπορείτε να κατεβάσετε το JAR χειροκίνητα). + +### Απαιτούμενες Βιβλιοθήκες και Εξαρτήσεις +Add GroupDocs.Search to your Maven project: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +For direct downloads, get the latest version from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Ρύθμιση Περιβάλλοντος +- Επαληθεύστε ότι το **JAVA_HOME** σας δείχνει σε συμβατό JDK. +- Δημιουργήστε ένα project στο IDE σας και προσθέστε τη Maven διαμόρφωση παραπάνω. +- Προετοιμάστε έναν κατάλογο (π.χ., `documents/`) με δείγμα κειμένου, PDF ή αρχεία Word. + +## Πώς να ρυθμίσετε το GroupDocs.Search για Java +1. **Εγκατάσταση της Βιβλιοθήκης** – Χρησιμοποιήστε το Maven snippet παραπάνω ή κατεβάστε το JAR από [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Απόκτηση Άδειας** – Ξεκινήστε με δοκιμαστική άδεια, στη συνέχεια αναβαθμίστε όταν μεταβείτε στην παραγωγή. +3. **Αρχικοποίηση του Δείκτη** – Το παρακάτω snippet δείχνει πώς να δημιουργήσετε (ή να ανοίξετε) έναν φάκελο δείκτη: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## Πώς να επισήμανση αποτελεσμάτων αναζήτησης Java – Συγχρονιστική Δεικτοδότηση +Synchronous indexing processes documents immediately, making newly added files searchable right away. + +### Βήμα 1: Δημιουργία του δείκτη και προσθήκη διαχείρισης σφαλμάτων +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Βήμα 2: Προσθήκη εγγράφων και εκτέλεση αναζήτησης +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Βήμα 3: Επεξεργασία αποτελεσμάτων και **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +The `DocumentHighlighter` automatically wraps matched terms with `` tags (or any format you configure), giving you **highlighted search results** ready for display. + +## Πώς να επισήμανση αποτελεσμάτων αναζήτησης Java – Ασύγχρονη Δεικτοδότηση +When dealing with thousands of files, blocking the main thread is undesirable. Asynchronous indexing lets the engine work in the background. + +### Βήμα 1: Ρύθμιση του δείκτη με ακροατές συμβάντων +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Βήμα 2: Ενεργοποίηση ασύγχρονης λειτουργίας και έναρξη δεικτοδότησης +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +While the index is being built, your application can continue to serve other requests. Once the `StatusChanged` event reports `Ready`, you can safely run searches and obtain **highlighted search results Java**. + +## Πώς να **index documents java** – Πρακτικές Συμβουλές +- **Batch size**: Για τεράστιες συλλογές, χωρίστε το φάκελο σε μικρότερα batch ώστε να αποφύγετε ξαφνικές αυξήσεις μνήμης. +- **File filters**: Χρησιμοποιήστε `IndexingOptions.setFileExtensions` για να συμπεριλάβετε μόνο τις μορφές που χρειάζεστε (π.χ., `.pdf`, `.docx`). +- **Re‑indexing**: Όταν τα έγγραφα αλλάζουν, καλέστε `index.update(documentPath)` αντί να ξαναχτίσετε ολόκληρο τον δείκτη. + +## Σκέψεις Απόδοσης +- **Memory**: Παρακολουθείτε τη χρήση heap· αυξήστε το `-Xmx` αν επεξεργάζεστε πολλά μεγάλα αρχεία. +- **CPU**: Η ασύγχρονη δεικτοδότηση διανέμει το φορτίο, αλλά εξακολουθεί να καταναλώνει CPU—παρακολουθήστε με το JVisualVM. +- **Result Highlighting**: Η επισήμανση προσθέτει μικρό κόστος επεξεργασίας· αποθηκεύστε στην cache το παραγόμενο HTML αν χρειάζεται να εμφανίζετε τα αποτελέσματα επανειλημμένα. + +## Συχνές Ερωτήσεις + +**Q: Μπορώ να συνδυάσω συγχρονιστική και ασύγχρονη δεικτοδότηση στην ίδια εφαρμογή;** +A: Ναι. Χρησιμοποιήστε συγχρονιστική δεικτοδότηση για μικρά, συχνά ενημερωμένα σύνολα και ασύγχρονη δεικτοδότηση για μαζικές εισαγωγές ή εργασίες παρασκηνίου. + +**Q: Πώς προσαρμόζω το στυλ της επισήμανσης;** +A: Παρέχετε μια προσαρμοσμένη υλοποίηση `DocumentHighlighter` που γράφει τις επιθυμητές ετικέτες HTML, CSS ή XML γύρω από τους ταιριασμένους όρους. + +**Q: Ποιοι τύποι αρχείων υποστηρίζει το GroupDocs.Search εξ' αρχής;** +A: Text, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML, και πολλά άλλα μέσω των ενσωματωμένων αναλυτών του. + +**Q: Είναι δυνατόν να αναζητήσω σε πολλαπλές γλώσσες ταυτόχρονα;** +A: Απόλυτα. Το GroupDocs.Search περιλαμβάνει πολυγλωσσικούς αναλυτές· απλώς ρυθμίστε τον κατάλληλο `Analyzer` κατά τη δημιουργία του δείκτη. + +**Q: Πώς ασφαλίζω το φάκελο του δείκτη;** +A: Αποθηκεύστε το δείκτη σε προστατευμένο κατάλογο, ορίστε σωστές άδειες συστήματος αρχείων και σκεφτείτε την κρυπτογράφηση του δείκτη με τις λειτουργίες ασφαλείας της βιβλιοθήκης. + +--- + +**Τελευταία Ενημέρωση:** 2026-02-08 +**Δοκιμή Με:** GroupDocs.Search 25.4 for Java +**Συγγραφέας:** GroupDocs \ No newline at end of file diff --git a/content/hindi/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/hindi/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..a2c2ed10 --- /dev/null +++ b/content/hindi/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,221 @@ +--- +date: '2026-02-08' +description: जावा में खोज परिणामों को हाइलाइट करना और GroupDocs.Search for Java का + उपयोग करके सिंक्रोनस और असिंक्रोनस इंडेक्सिंग के साथ दस्तावेज़ों को इंडेक्स करना + सीखें। +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: हाइलाइट सर्च परिणाम जावा – सिंक्रोनस और असिंक्रोनस इंडेक्सिंग +type: docs +url: /hi/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + + unchanged. + +Now produce final answer.# हाइलाइट सर्च रिज़ल्ट्स जावा – सिंक्रोनस & एसिंक्रोनस इंडेक्सिंग + +Boost your Java applications by **highlighting search results Java** with the powerful GroupDocs.Search library. Whether you’re dealing with a few files or a massive repository, mastering both synchronous and asynchronous indexing lets you deliver fast, accurate results without blocking your application threads. + +## त्वरित उत्तर +- **What does “highlight search results Java” mean?** यह उन मिलते हुए शब्दों को खोज परिणामों में दृश्य संकेत (जैसे, HTML `` टैग) के साथ रेंडर करने को कहा जाता है ताकि उपयोगकर्ता देख सकें कि क्वेरी प्रत्येक दस्तावेज़ में कहां दिखाई देती है। +- **When should I use synchronous indexing?** छोटे से मध्यम डेटा सेट्स के लिए जहाँ नई जोड़ी गई दस्तावेज़ों की तुरंत उपलब्धता आवश्यक होती है, सिंक्रोनस इंडेक्सिंग का उपयोग करें। +- **When is asynchronous indexing preferable?** बड़े दस्तावेज़ संग्रह को प्रोसेस करते समय या UI थ्रेड पर चलाते समय जहाँ एप्लिकेशन को प्रतिक्रियाशील रखना आवश्यक है, असिंक्रोनस इंडेक्सिंग बेहतर है। +- **Do I need a license?** विकास के लिए एक फ्री ट्रायल काम करता है; पूर्ण लाइसेंस उन्नत फीचर्स अनलॉक करता है और उपयोग सीमा हटाता है। +- **Which Java version is supported?** Java 8 या उसके बाद का संस्करण। + +## “highlight search results Java” क्या है? +जावा में सर्च रिज़ल्ट्स को हाइलाइट करना मतलब GroupDocs.Search द्वारा लौटाए गए कच्चे मैचेज़ को लेना और मिलते हुए शब्दों को HTML (या किसी अन्य मार्कअप) में लपेटना है ताकि वे UI या वेब पेज में प्रदर्शित होने पर स्पष्ट दिखें। यह प्रत्येक हिट के संदर्भ को तुरंत दिखाकर उपयोगकर्ता अनुभव को बेहतर बनाता है। + +## जावा के लिए GroupDocs.Search क्यों उपयोग करें? +GroupDocs.Search एक हाई‑परफ़ॉर्मेंस, भाषा‑अग्नॉस्टिक इंजन प्रदान करता है जो समर्थन करता है: +- रियल‑टाइम इंडेक्सिंग और सर्चिंग +- बड़े वर्कलोड्स के लिए असिंक्रोनस प्रोसेसिंग +- बिल्ट‑इन रिज़ल्ट हाइलाइटिंग +- मल्टी‑लैंग्वेज और कस्टम एनालाइज़र सपोर्ट + +## पूर्वापेक्षाएँ +शुरू करने से पहले, सुनिश्चित करें कि आपके पास है: +- **Java Development Kit** (JDK 8 या नया) स्थापित हो। +- **IntelliJ IDEA** या **Eclipse** जैसे IDE। +- एक फ़ोल्डर जिसमें आप इंडेक्स करना चाहते दस्तावेज़ हों। +- डिपेंडेंसी मैनेजमेंट के लिए Maven (या आप JAR मैन्युअली डाउनलोड कर सकते हैं)। + +### आवश्यक लाइब्रेरीज़ और डिपेंडेंसिज़ +अपने Maven प्रोजेक्ट में GroupDocs.Search जोड़ें: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +डायरेक्ट डाउनलोड के लिए, नवीनतम संस्करण यहाँ से प्राप्त करें: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### पर्यावरण सेटअप +- सुनिश्चित करें कि आपका **JAVA_HOME** संगत JDK की ओर इशारा कर रहा है। +- अपने IDE में एक प्रोजेक्ट बनाएं और ऊपर दिया गया Maven कॉन्फ़िगरेशन जोड़ें। +- एक डायरेक्टरी (जैसे, `documents/`) तैयार करें जिसमें सैंपल टेक्स्ट, PDF, या Word फ़ाइलें हों। + +## GroupDocs.Search को जावा के लिए सेट अप कैसे करें +1. **Install the Library** – ऊपर दिया गया Maven स्निपेट उपयोग करें या JAR को यहाँ से डाउनलोड करें: [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Obtain a License** – पहले ट्रायल लाइसेंस से शुरू करें, फिर प्रोडक्शन में जाने पर अपग्रेड करें। +3. **Initialize the Index** – नीचे दिया गया स्निपेट दिखाता है कि कैसे (या खोलें) एक इंडेक्स फ़ोल्डर बनाएं: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## जावा में सर्च रिज़ल्ट्स को हाइलाइट कैसे करें – सिंक्रोनस इंडेक्सिंग +सिंक्रोनस इंडेक्सिंग दस्तावेज़ों को तुरंत प्रोसेस करती है, जिससे नई जोड़ी गई फ़ाइलें तुरंत सर्चेबल हो जाती हैं। + +### चरण 1: इंडेक्स बनाएं और एरर हैंडलिंग जोड़ें +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### चरण 2: दस्तावेज़ जोड़ें और सर्च चलाएँ +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### चरण 3: परिणाम प्रोसेस करें और **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +`DocumentHighlighter` स्वचालित रूप से मिलते हुए शब्दों को `` टैग (या आपके द्वारा कॉन्फ़िगर किया गया कोई भी फॉर्मेट) में लपेटता है, जिससे आपको **हाइलाइटेड सर्च रिज़ल्ट्स** डिस्प्ले के लिए तैयार मिलते हैं। + +## जावा में सर्च रिज़ल्ट्स को हाइलाइट कैसे करें – असिंक्रोनस इंडेक्सिंग +हजारों फ़ाइलों से निपटते समय मुख्य थ्रेड को ब्लॉक करना अनचाहा होता है। असिंक्रोनस इंडेक्सिंग इंजन को बैकग्राउंड में काम करने देता है। + +### चरण 1: इवेंट लिस्नर्स के साथ इंडेक्स सेट अप करें +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### चरण 2: असिंक्रोनस मोड सक्षम करें और इंडेक्सिंग शुरू करें +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +जब इंडेक्स बन रहा हो, आपका एप्लिकेशन अन्य अनुरोधों को सर्व करना जारी रख सकता है। जब `StatusChanged` इवेंट `Ready` रिपोर्ट करे, तब आप सुरक्षित रूप से सर्च चला सकते हैं और **highlighted search results Java** प्राप्त कर सकते हैं। + +## **index documents java** कैसे करें – व्यावहारिक टिप्स +- **Batch size**: बड़े कलेक्शन के लिए, फ़ोल्डर को छोटे बैच में विभाजित करें ताकि मेमोरी स्पाइक से बचा जा सके। +- **File filters**: केवल आवश्यक फ़ॉर्मेट (जैसे, `.pdf`, `.docx`) शामिल करने के लिए `IndexingOptions.setFileExtensions` उपयोग करें। +- **Re‑indexing**: जब दस्तावेज़ बदलें, तो पूरे इंडेक्स को रीबिल्ड करने के बजाय `index.update(documentPath)` कॉल करें। + +## प्रदर्शन संबंधी विचार +- **Memory**: हीप उपयोग पर नज़र रखें; यदि आप कई बड़ी फ़ाइलें प्रोसेस कर रहे हैं तो `-Xmx` बढ़ाएँ। +- **CPU**: असिंक्रोनस इंडेक्सिंग वर्कलोड को फैलाता है, लेकिन फिर भी CPU खपत करता है—JVisualVM से मॉनिटर करें। +- **Result Highlighting**: हाइलाइटिंग थोड़ा प्रोसेसिंग ओवरहेड जोड़ता है; यदि आपको परिणाम बार‑बार दिखाने हैं तो जेनरेटेड HTML को कैश करें। + +## अक्सर पूछे जाने वाले प्रश्न + +**Q: क्या मैं एक ही एप्लिकेशन में सिंक्रोनस और असिंक्रोनस दोनों इंडेक्सिंग को संयोजित कर सकता हूँ?** +A: हाँ। छोटे, अक्सर अपडेट होने वाले सेट्स के लिए सिंक्रोनस इंडेक्सिंग और बड़े इम्पोर्ट या बैकग्राउंड जॉब्स के लिए असिंक्रोनस इंडेक्सिंग उपयोग करें। + +**Q: हाइलाइट स्टाइल को कैसे कस्टमाइज़ करूँ?** +A: एक कस्टम `DocumentHighlighter` इम्प्लीमेंटेशन प्रदान करें जो मिलते हुए शब्दों के चारों ओर वांछित HTML, CSS, या XML टैग लिखे। + +**Q: GroupDocs.Search डिफ़ॉल्ट रूप से कौन-से फ़ाइल प्रकारों को सपोर्ट करता है?** +A: टेक्स्ट, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML, और कई अन्य उसके बिल्ट‑इन पार्सर्स के माध्यम से। + +**Q: क्या एक साथ कई भाषाओं में सर्च करना संभव है?** +A: बिल्कुल। GroupDocs.Search में मल्टी‑लैंग्वेज एनालाइज़र शामिल हैं; इंडेक्स बनाते समय उचित `Analyzer` कॉन्फ़िगर करें। + +**Q: मैं इंडेक्स फ़ोल्डर को कैसे सुरक्षित करूँ?** +A: इंडेक्स को एक प्रोटेक्टेड डायरेक्टरी में रखें, उचित फ़ाइल सिस्टम परमिशन सेट करें, और लाइब्रेरी की सुरक्षा सुविधाओं से इंडेक्स को एन्क्रिप्ट करने पर विचार करें। + +--- + +**अंतिम अपडेट:** 2026-02-08 +**परीक्षण किया गया:** GroupDocs.Search 25.4 for Java +**लेखक:** GroupDocs \ No newline at end of file diff --git a/content/hongkong/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/hongkong/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..754b246e --- /dev/null +++ b/content/hongkong/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,220 @@ +--- +date: '2026-02-08' +description: 了解如何使用 GroupDocs.Search for Java 在 Java 中對搜尋結果進行高亮顯示，以及如何透過同步與非同步索引來索引文件。 +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: 突出顯示搜尋結果 Java – 同步與非同步索引 +type: docs +url: /zh-hant/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Highlight Search Results Java – Synchronous & Async Indexing + +透過功能強大的 GroupDocs.Search 程式庫，為您的 Java 應用程式 **highlight search results Java** 加上醒目標示。無論是少量檔案或龐大儲存庫，熟悉同步與非同步索引皆能讓您在不阻塞執行緒的情況下，提供快速且精確的搜尋結果。 + +## Quick Answers +- **What does “highlight search results Java” mean?** 它指的是在搜尋結果中以視覺提示（例如 HTML `` 標籤）呈現匹配的關鍵字，讓使用者一眼看出查詢字詞在每份文件中的出現位置。 +- **When should I use synchronous indexing?** 適用於小至中等規模的資料集，且需要即時取得新加入文件的情況。 +- **When is asynchronous indexing preferable?** 當處理大型文件集合或在 UI 執行緒上執行時，需要保持應用程式的回應性。 +- **Do I need a license?** 開發階段可使用免費試用版；完整授權可解鎖進階功能並移除使用限制。 +- **Which Java version is supported?** Java 8 或更新版本。 + +## What is “highlight search results Java”? +在 Java 中對搜尋結果進行醒目標示，意指將 GroupDocs.Search 回傳的原始匹配項目以 HTML（或其他標記）包裹，使其在 UI 或網頁上顯示時更加突出。此舉可即時呈現每筆命中的上下文，提升使用者體驗。 + +## Why use GroupDocs.Search for Java? +GroupDocs.Search 提供高效能、語言無關的搜尋引擎，具備以下特點： +- 即時索引與搜尋 +- 大量工作負載的非同步處理 +- 內建結果醒目標示 +- 多語言與自訂分析器支援 + +這些功能使其非常適合內容管理系統、電子商務目錄與企業文件庫等應用場景。 + +## Prerequisites +開始之前，請確保您已具備： + +- 已安裝 **Java Development Kit**（JDK 8 或更新版本）。 +- 如 **IntelliJ IDEA** 或 **Eclipse** 等開發環境。 +- 包含欲索引文件的資料夾。 +- 用於相依管理的 Maven（或自行下載 JAR）。 + +### Required Libraries and Dependencies +將 GroupDocs.Search 加入您的 Maven 專案： + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +若直接下載，請前往 [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) 取得最新版本。 + +### Environment Setup +- 確認 **JAVA_HOME** 指向相容的 JDK。 +- 在 IDE 中建立專案，並加入上述 Maven 設定。 +- 準備一個目錄（例如 `documents/`），內放範例文字、PDF 或 Word 檔案。 + +## How to set up GroupDocs.Search for Java +1. **Install the Library** – 使用上方的 Maven 片段或從 [GroupDocs](https://releases.groupdocs.com/search/java/) 下載 JAR。 +2. **Obtain a License** – 先取得試用授權，正式上線時再升級為正式授權。 +3. **Initialize the Index** – 以下程式碼示範如何建立（或開啟）索引資料夾： + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## How to highlight search results Java – Synchronous Indexing +同步索引會立即處理文件，使新加入的檔案即時可被搜尋。 + +### Step 1: Create the index and attach error handling +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Step 2: Add documents and run a search +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Step 3: Process results and **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +`DocumentHighlighter` 會自動以 `` 標籤（或您自訂的格式）包裹匹配的字詞，產生 **highlighted search results**，即可直接顯示。 + +## How to highlight search results Java – Asynchronous Indexing +面對數千檔案時，阻塞主執行緒並非理想做法。非同步索引讓引擎在背景執行。 + +### Step 1: Set up the index with event listeners +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Step 2: Enable asynchronous mode and start indexing +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +索引建構期間，您的應用程式仍可處理其他請求。當 `StatusChanged` 事件回報 `Ready` 後，即可安全執行搜尋並取得 **highlighted search results Java**。 + +## How to **index documents java** – Practical Tips +- **Batch size**：對於龐大集合，將資料夾切分為較小批次，以避免記憶體激增。 +- **File filters**：使用 `IndexingOptions.setFileExtensions` 僅納入所需格式（例如 `.pdf`、`.docx`）。 +- **Re‑indexing**：文件變更時，呼叫 `index.update(documentPath)` 而非重新建立整個索引。 + +## Performance Considerations +- **Memory**：留意堆積使用量；若處理大量大型檔案，請調整 `-Xmx`。 +- **CPU**：非同步索引會分散工作負載，但仍會佔用 CPU，建議使用 JVisualVM 監控。 +- **Result Highlighting**：醒目標示會產生少量額外開銷；若需頻繁顯示結果，可快取產生的 HTML。 + +## Frequently Asked Questions + +**Q: Can I combine synchronous and asynchronous indexing in the same application?** +A: 可以。對於小型且頻繁更新的資料集使用同步索引，對於大量匯入或背景工作則使用非同步索引。 + +**Q: How do I customize the highlight style?** +A: 實作自訂的 `DocumentHighlighter`，在匹配字詞周圍寫入您想要的 HTML、CSS 或 XML 標籤。 + +**Q: What file types does GroupDocs.Search support out of the box?** +A: 支援 Text、PDF、DOC/DOCX、XLS/XLSX、PPT/PPTX、HTML 等多種格式，亦可透過內建解析器擴充更多類型。 + +**Q: Is it possible to search in multiple languages simultaneously?** +A: 完全可以。GroupDocs.Search 內建多語言分析器，只要在建立索引時設定相應的 `Analyzer` 即可。 + +**Q: How do I secure the index folder?** +A: 將索引存放於受保護的目錄，設定正確的檔案系統權限，並可使用程式庫提供的加密功能對索引進行加密。 + +--- + +**Last Updated:** 2026-02-08 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs \ No newline at end of file diff --git a/content/hungarian/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/hungarian/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..497e56f8 --- /dev/null +++ b/content/hungarian/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,226 @@ +--- +date: '2026-02-08' +description: Tanulja meg, hogyan emelje ki a keresési eredményeket Java-ban, és hogyan + indexeljen dokumentumokat Java-val a GroupDocs.Search for Java segítségével szinkron + és aszinkron indexeléssel. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Keresési eredmények kiemelése Java – Szinkron és aszinkron indexelés +type: docs +url: /hu/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + + + +Make sure to keep markdown formatting. + +Now produce final content.# Highlight Search Results Java – Szinkron és Aszinkron indexelés + +Boost your Java applications by **highlighting search results Java** with the powerful GroupDocs.Search library. Whether you’re dealing with a few files or a massive repository, mastering both synchronous and asynchronous indexing lets you deliver fast, accurate results without blocking your application threads. + +## Gyors válaszok +- **Mit jelent a “highlight search results Java”?** Ez a keresési eredményekben a megtalált kifejezések vizuális jelzéssel (pl. HTML `` címkék) való megjelenítését jelenti, hogy a felhasználók láthassák, hol fordul elő a lekérdezés az egyes dokumentumokban. +- **Mikor kell szinkron indexelést használni?** Kis- és közepes méretű adatkészleteknél, ahol az újonnan hozzáadott dokumentumok azonnali elérhetősége szükséges. +- **Mikor előnyösebb az aszinkron indexelés?** Nagy dokumentumgyűjtemények feldolgozásakor vagy UI szálon futtatáskor, ahol az alkalmazásnak reagálónak kell maradnia. +- **Szükségem van licencre?** A fejlesztéshez ingyenes próba verzió is elegendő; egy teljes licenc feloldja a fejlett funkciókat és eltávolítja a használati korlátokat. +- **Melyik Java verzió támogatott?** Java 8 vagy újabb. + +## Mi a “highlight search results Java”? +A keresési eredmények kiemelése Java-ban azt jelenti, hogy a GroupDocs.Search által visszaadott nyers találatokat HTML‑ben (vagy más jelölőnyelvben) körülvegyük, hogy a kifejezések kiemelkedjenek egy UI‑ban vagy weboldalon megjelenítve. Ez javítja a felhasználói élményt azzal, hogy azonnal megmutatja az egyes találatok környezetét. + +## Miért használjuk a GroupDocs.Search‑t Java‑hoz? +GroupDocs.Search provides a high‑performance, language‑agnostic engine that supports: +- Valós idejű indexelés és keresés +- Aszinkron feldolgozás nagy terhelés esetén +- Beépített eredménykiemelés +- Többnyelvű és egyedi elemző támogatás + +These capabilities make it ideal for content management systems, e‑commerce catalogs, and enterprise document repositories. + +## Előfeltételek +Before you start, make sure you have: + +- **Java Development Kit** (JDK 8 vagy újabb) telepítve. +- IDE, például **IntelliJ IDEA** vagy **Eclipse**. +- Egy mappa, amely a indexelni kívánt dokumentumokat tartalmazza. +- Maven a függőségek kezeléséhez (vagy a JAR‑t manuálisan letöltheted). + +### Szükséges könyvtárak és függőségek +Add GroupDocs.Search to your Maven project: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +For direct downloads, get the latest version from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Környezet beállítása +- Ellenőrizd, hogy a **JAVA_HOME** egy kompatibilis JDK‑ra mutat. +- Hozz létre egy projektet az IDE‑ben, és add hozzá a fenti Maven konfigurációt. +- Készíts egy könyvtárat (pl. `documents/`) mintaszövegekkel, PDF‑ vagy Word‑fájlokkal. + +## A GroupDocs.Search Java‑hoz történő beállítása +1. **Telepítsd a könyvtárat** – Használd a fenti Maven kódrészletet vagy töltsd le a JAR‑t a [GroupDocs](https://releases.groupdocs.com/search/java/) oldalról. +2. **Szerezz licencet** – Kezdd próba licenccel, majd frissíts, amikor éles környezetbe lépsz. +3. **Az index inicializálása** – Az alábbi kódrészlet mutatja, hogyan hozhatsz létre (vagy nyithatsz meg) egy index mappát: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## A highlight search results Java – Szinkron indexelés +Synchronous indexing processes documents immediately, making newly added files searchable right away. + +### 1. lépés: Az index létrehozása és hibakezelés csatolása +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### 2. lépés: Dokumentumok hozzáadása és keresés futtatása +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### 3. lépés: Eredmények feldolgozása és **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +The `DocumentHighlighter` automatically wraps matched terms with `` tags (or any format you configure), giving you **highlighted search results** ready for display. + +## A highlight search results Java – Aszinkron indexelés +When dealing with thousands of files, blocking the main thread is undesirable. Asynchronous indexing lets the engine work in the background. + +### 1. lépés: Az index beállítása eseményfigyelőkkel +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### 2. lépés: Aszinkron mód engedélyezése és indexelés indítása +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +While the index is being built, your application can continue to serve other requests. Once the `StatusChanged` event reports `Ready`, you can safely run searches and obtain **highlighted search results Java**. + +## Hogyan **index documents java** – Gyakorlati tippek +- **Batch size**: Nagy gyűjtemények esetén oszd fel a mappát kisebb kötegekre a memóriahullámok elkerülése érdekében. +- **File filters**: Használd az `IndexingOptions.setFileExtensions` metódust, hogy csak a szükséges formátumokat (pl. `.pdf`, `.docx`) vedd fel. +- **Re‑indexing**: Ha a dokumentumok változnak, hívd a `index.update(documentPath)` metódust a teljes index újraépítése helyett. + +## Teljesítménybeli megfontolások +- **Memory**: Figyeld a heap használatát; növeld a `-Xmx` értéket, ha sok nagy fájlt dolgozol fel. +- **CPU**: Az aszinkron indexelés elosztja a terhelést, de még mindig CPU‑t használ—figyeld a JVisualVM‑mel. +- **Result Highlighting**: A kiemelés kis feldolgozási többletet jelent; ha többször kell megjeleníteni az eredményeket, cache-eld a generált HTML‑t. + +## Gyakran ismételt kérdések + +**Kérdés: Kombinálhatom a szinkron és aszinkron indexelést ugyanabban az alkalmazásban?** +**Válasz:** Igen. Használj szinkron indexelést kis, gyakran frissített készletekhez és aszinkron indexelést tömeges importokhoz vagy háttérfeladatokhoz. + +**Kérdés: Hogyan testreszabhatom a kiemelés stílusát?** +**Válasz:** Adj meg egy egyedi `DocumentHighlighter` implementációt, amely a kívánt HTML‑t, CSS‑t vagy XML‑címkéket írja a megtalált kifejezések köré. + +**Kérdés: Milyen fájltípusokat támogat a GroupDocs.Search alapból?** +**Válasz:** Szöveg, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML, és még sok más a beépített parser‑ek révén. + +**Kérdés: Lehetséges egyszerre több nyelven keresni?** +**Válasz:** Természetesen. A GroupDocs.Search tartalmaz többnyelvű elemzőket; csak állítsd be a megfelelő `Analyzer`‑t az index létrehozásakor. + +**Kérdés: Hogyan biztosíthatom az index mappát?** +**Válasz:** Tedd az indexet védett könyvtárba, állíts be megfelelő fájlrendszer jogosultságokat, és fontold meg az index titkosítását a könyvtár biztonsági funkcióival. + +--- + +**Last Updated:** 2026-02-08 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs \ No newline at end of file diff --git a/content/indonesian/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/indonesian/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..f34072e8 --- /dev/null +++ b/content/indonesian/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,221 @@ +--- +date: '2026-02-08' +description: Pelajari cara menyorot hasil pencarian di Java dan cara mengindeks dokumen + Java menggunakan GroupDocs.Search untuk Java dengan pengindeksan sinkron dan asinkron. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Sorot Hasil Pencarian Java – Pengindeksan Sinkron & Asinkron +type: docs +url: /id/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Highlight Search Results Java – Synchronous & Async Indexing + +Tingkatkan aplikasi Java Anda dengan **highlighting search results Java** menggunakan pustaka GroupDocs.Search yang kuat. Baik Anda menangani beberapa file maupun repositori besar, menguasai indeksasi sinkron dan asinkron memungkinkan Anda memberikan hasil yang cepat dan akurat tanpa memblokir thread aplikasi. + +## Quick Answers +- **What does “highlight search results Java” mean?** It refers to rendering matched terms in search results with visual cues (e.g., HTML `` tags) so users can see where the query appears in each document. +- **When should I use synchronous indexing?** For small to medium data sets where immediate availability of newly added documents is required. +- **When is asynchronous indexing preferable?** When processing large document collections or running on a UI thread where you must keep the application responsive. +- **Do I need a license?** A free trial works for development; a full license unlocks advanced features and removes usage limits. +- **Which Java version is supported?** Java 8 or later. + +## What is “highlight search results Java”? +Highlighting search results in Java means taking the raw matches returned by GroupDocs.Search and wrapping the matching terms in HTML (or another markup) so they stand out when displayed in a UI or web page. This improves user experience by instantly showing the context of each hit. + +## Why use GroupDocs.Search for Java? +GroupDocs.Search provides a high‑performance, language‑agnostic engine that supports: +- Real‑time indexing and searching +- Asynchronous processing for large workloads +- Built‑in result highlighting +- Multi‑language and custom analyzer support + +These capabilities make it ideal for content management systems, e‑commerce catalogs, and enterprise document repositories. + +## Prerequisites +Before you start, make sure you have: + +- **Java Development Kit** (JDK 8 or newer) installed. +- An IDE such as **IntelliJ IDEA** or **Eclipse**. +- A folder containing the documents you want to index. +- Maven for dependency management (or you can download the JAR manually). + +### Required Libraries and Dependencies +Add GroupDocs.Search to your Maven project: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +For direct downloads, get the latest version from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Environment Setup +- Verify your **JAVA_HOME** points to a compatible JDK. +- Create a project in your IDE and add the Maven configuration above. +- Prepare a directory (e.g., `documents/`) with sample text, PDF, or Word files. + +## How to set up GroupDocs.Search for Java +1. **Install the Library** – Use the Maven snippet above or download the JAR from [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Obtain a License** – Start with a trial license, then upgrade when you move to production. +3. **Initialize the Index** – The following snippet shows how to create (or open) an index folder: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## How to highlight search results Java – Synchronous Indexing +Synchronous indexing processes documents immediately, making newly added files searchable right away. + +### Step 1: Create the index and attach error handling +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Step 2: Add documents and run a search +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Step 3: Process results and **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +The `DocumentHighlighter` automatically wraps matched terms with `` tags (or any format you configure), giving you **highlighted search results** ready for display. + +## How to highlight search results Java – Asynchronous Indexing +When dealing with thousands of files, blocking the main thread is undesirable. Asynchronous indexing lets the engine work in the background. + +### Step 1: Set up the index with event listeners +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Step 2: Enable asynchronous mode and start indexing +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +While the index is being built, your application can continue to serve other requests. Once the `StatusChanged` event reports `Ready`, you can safely run searches and obtain **highlighted search results Java**. + +## How to **index documents java** – Practical Tips +- **Batch size**: For huge collections, split the folder into smaller batches to avoid memory spikes. +- **File filters**: Use `IndexingOptions.setFileExtensions` to include only the formats you need (e.g., `.pdf`, `.docx`). +- **Re‑indexing**: When documents change, call `index.update(documentPath)` instead of rebuilding the whole index. + +## Performance Considerations +- **Memory**: Keep an eye on heap usage; increase `-Xmx` if you process many large files. +- **CPU**: Asynchronous indexing spreads the workload, but still consumes CPU—monitor with JVisualVM. +- **Result Highlighting**: Highlighting adds a small processing overhead; cache the generated HTML if you need to display results repeatedly. + +## Frequently Asked Questions + +**Q: Can I combine synchronous and asynchronous indexing in the same application?** +A: Yes. Use synchronous indexing for small, frequently updated sets and asynchronous indexing for bulk imports or background jobs. + +**Q: How do I customize the highlight style?** +A: Provide a custom `DocumentHighlighter` implementation that writes the desired HTML, CSS, or XML tags around matched terms. + +**Q: What file types does GroupDocs.Search support out of the box?** +A: Text, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML, and many more via its built‑in parsers. + +**Q: Is it possible to search in multiple languages simultaneously?** +A: Absolutely. GroupDocs.Search includes multi‑language analyzers; just configure the appropriate `Analyzer` when creating the index. + +**Q: How do I secure the index folder?** +A: Store the index in a protected directory, set proper file system permissions, and consider encrypting the index with the library’s security features. + +--- + +**Last Updated:** 2026-02-08 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs \ No newline at end of file diff --git a/content/italian/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/italian/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..f0e625e1 --- /dev/null +++ b/content/italian/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,222 @@ +--- +date: '2026-02-08' +description: Scopri come evidenziare i risultati di ricerca in Java e come indicizzare + i documenti Java usando GroupDocs.Search per Java con indicizzazione sincrona e + asincrona. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Evidenzia i risultati di ricerca Java – Indicizzazione sincrona e asincrona +type: docs +url: /it/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Evidenzia i risultati di ricerca Java – Indicizzazione sincrona e asincrona + +Migliora le tue applicazioni Java **evidenziando i risultati di ricerca Java** con la potente libreria GroupDocs.Search. Che tu stia gestendo pochi file o un repository massiccio, padroneggiare sia l'indicizzazione sincrona che quella asincrona ti permette di fornire risultati rapidi e precisi senza bloccare i thread della tua applicazione. + +## Risposte rapide +- **Cosa significa “highlight search results Java”?** Si riferisce al rendering dei termini corrispondenti nei risultati di ricerca con indicazioni visive (ad es., tag HTML ``) in modo che gli utenti possano vedere dove la query appare in ciascun documento. +- **Quando dovrei usare l'indicizzazione sincrona?** Per set di dati piccoli o medi dove è necessaria la disponibilità immediata dei documenti appena aggiunti. +- **Quando è preferibile l'indicizzazione asincrona?** Quando si elaborano grandi collezioni di documenti o si esegue su un thread UI dove è necessario mantenere l'applicazione reattiva. +- **Ho bisogno di una licenza?** Una prova gratuita è sufficiente per lo sviluppo; una licenza completa sblocca funzionalità avanzate e rimuove i limiti di utilizzo. +- **Quale versione di Java è supportata?** Java 8 o successiva. + +## Cos'è “highlight search results Java”? +Evidenziare i risultati di ricerca in Java significa prendere le corrispondenze grezze restituite da GroupDocs.Search e avvolgere i termini corrispondenti in HTML (o un altro markup) in modo che risaltino quando visualizzati in un'interfaccia utente o in una pagina web. Questo migliora l'esperienza dell'utente mostrando istantaneamente il contesto di ogni risultato. + +## Perché usare GroupDocs.Search per Java? +GroupDocs.Search fornisce un motore ad alte prestazioni, indipendente dalla lingua, che supporta: +- Indicizzazione e ricerca in tempo reale +- Elaborazione asincrona per carichi di lavoro elevati +- Evidenziazione dei risultati integrata +- Supporto multilingua e analizzatori personalizzati + +Queste capacità lo rendono ideale per sistemi di gestione dei contenuti, cataloghi e‑commerce e repository di documenti aziendali. + +## Prerequisiti +Prima di iniziare, assicurati di avere: + +- **Java Development Kit** (JDK 8 o più recente) installato. +- Un IDE come **IntelliJ IDEA** o **Eclipse**. +- Una cartella contenente i documenti che desideri indicizzare. +- Maven per la gestione delle dipendenze (oppure puoi scaricare manualmente il JAR). + +### Librerie e dipendenze richieste +Aggiungi GroupDocs.Search al tuo progetto Maven: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Per download diretti, ottieni l'ultima versione da [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Configurazione dell'ambiente +- Verifica che il tuo **JAVA_HOME** punti a un JDK compatibile. +- Crea un progetto nel tuo IDE e aggiungi la configurazione Maven sopra. +- Prepara una directory (ad es., `documents/`) con file di testo, PDF o Word di esempio. + +## Come configurare GroupDocs.Search per Java +1. **Installa la libreria** – Usa lo snippet Maven sopra o scarica il JAR da [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Ottieni una licenza** – Inizia con una licenza di prova, poi effettua l'upgrade quando passi alla produzione. +3. **Inizializza l'indice** – Il frammento seguente mostra come creare (o aprire) una cartella indice: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## Come evidenziare i risultati di ricerca Java – Indicizzazione sincrona +L'indicizzazione sincrona elabora i documenti immediatamente, rendendo i file appena aggiunti ricercabili subito. + +### Passo 1: Crea l'indice e aggiungi la gestione degli errori +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Passo 2: Aggiungi i documenti ed esegui una ricerca +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Passo 3: Elabora i risultati e **evidenzia i risultati di ricerca Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +`DocumentHighlighter` avvolge automaticamente i termini corrispondenti con i tag `` (o qualsiasi formato tu configuri), fornendoti **risultati di ricerca evidenziati** pronti per la visualizzazione. + +## Come evidenziare i risultati di ricerca Java – Indicizzazione asincrona +Quando si gestiscono migliaia di file, bloccare il thread principale è indesiderabile. L'indicizzazione asincrona consente al motore di lavorare in background. + +### Passo 1: Configura l'indice con i listener di eventi +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Passo 2: Abilita la modalità asincrona e avvia l'indicizzazione +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +Mentre l'indice viene costruito, la tua applicazione può continuare a gestire altre richieste. Una volta che l'evento `StatusChanged` segnala `Ready`, puoi eseguire ricerche in sicurezza e ottenere **risultati di ricerca evidenziati Java**. + +## Come **indicizzare documenti java** – Consigli pratici +- **Dimensione batch**: Per collezioni enormi, suddividi la cartella in batch più piccoli per evitare picchi di memoria. +- **Filtri file**: Usa `IndexingOptions.setFileExtensions` per includere solo i formati necessari (ad es., `.pdf`, `.docx`). +- **Re‑indicizzazione**: Quando i documenti cambiano, chiama `index.update(documentPath)` invece di ricostruire l'intero indice. + +## Considerazioni sulle prestazioni +- **Memoria**: Tieni sotto controllo l'uso dell'heap; aumenta `-Xmx` se elabori molti file di grandi dimensioni. +- **CPU**: L'indicizzazione asincrona distribuisce il carico di lavoro, ma consuma comunque CPU—monitorala con JVisualVM. +- **Evidenziazione dei risultati**: L'evidenziazione aggiunge un piccolo overhead di elaborazione; memorizza nella cache l'HTML generato se devi visualizzare i risultati più volte. + +## Domande frequenti + +**Q: Posso combinare indicizzazione sincrona e asincrona nella stessa applicazione?** +A: Sì. Usa l'indicizzazione sincrona per set piccoli e frequentemente aggiornati e l'indicizzazione asincrona per importazioni massive o lavori in background. + +**Q: Come personalizzo lo stile di evidenziazione?** +A: Fornisci un'implementazione personalizzata di `DocumentHighlighter` che scriva i tag HTML, CSS o XML desiderati attorno ai termini corrispondenti. + +**Q: Quali tipi di file supporta GroupDocs.Search nativamente?** +A: Text, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML e molti altri tramite i suoi parser integrati. + +**Q: È possibile cercare in più lingue simultaneamente?** +A: Assolutamente. GroupDocs.Search include analizzatori multilingua; basta configurare l'`Analyzer` appropriato quando crei l'indice. + +**Q: Come proteggere la cartella indice?** +A: Conserva l'indice in una directory protetta, imposta i permessi corretti del file system e considera la crittografia dell'indice con le funzionalità di sicurezza della libreria. + +--- + +**Ultimo aggiornamento:** 2026-02-08 +**Testato con:** GroupDocs.Search 25.4 per Java +**Autore:** GroupDocs \ No newline at end of file diff --git a/content/japanese/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/japanese/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..f7ebb9b8 --- /dev/null +++ b/content/japanese/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,221 @@ +--- +date: '2026-02-08' +description: GroupDocs.Search for Java を使用して、同期インデックスと非同期インデックスを活用した検索結果のハイライト方法と、Java + でのドキュメントのインデックス作成方法を学びましょう。 +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: ハイライト検索結果 Java – 同期＆非同期インデックス作成 +type: docs +url: /ja/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# 検索結果のハイライト Java – 同期 & 非同期 インデックス作成 + +強力な GroupDocs.Search ライブラリを使用して **highlighting search results Java** によって Java アプリケーションを強化しましょう。少数のファイルでも大規模なリポジトリでも、同期インデックスと非同期インデックスの両方をマスターすれば、アプリケーションスレッドをブロックせずに高速で正確な結果を提供できます。 + +## Quick Answers +- **“highlight search results Java” とは何ですか？** 検索結果に一致した語句を視覚的なヒント（例: HTML の `` タグ）で表示し、ユーザーが各ドキュメント内でクエリがどこに現れるかを確認できるようにすることです。 +- **同期インデックスはいつ使用すべきですか？** 小規模から中規模のデータセットで、追加されたドキュメントを即座に利用可能にしたい場合に適しています。 +- **非同期インデックスはいつ好ましいですか？** 大量のドキュメントコレクションを処理する場合や、UI スレッド上でアプリケーションの応答性を保ちたい場合に最適です。 +- **ライセンスは必要ですか？** 開発用には無料トライアルで十分です。フルライセンスを取得すると高度な機能が解放され、使用制限が解除されます。 +- **サポートされている Java バージョンは？** Java 8 以降。 + +## “highlight search results Java” とは？ +Java で検索結果をハイライトするとは、GroupDocs.Search が返す生のマッチ情報に対して一致した語句を HTML（または別のマークアップ）でラップし、UI やウェブページに表示したときに目立たせることを指します。これにより、各ヒットのコンテキストが瞬時に示され、ユーザー体験が向上します。 + +## なぜ GroupDocs.Search for Java を使うのか？ +GroupDocs.Search は高性能で言語に依存しないエンジンを提供し、以下をサポートします： +- リアルタイムのインデックス作成と検索 +- 大規模ワークロード向けの非同期処理 +- 組み込みの結果ハイライト機能 +- 多言語およびカスタムアナライザーのサポート + +これらの機能により、コンテンツ管理システム、eコマースカタログ、エンタープライズ文書リポジトリなどに最適です。 + +## 前提条件 +開始する前に以下を確認してください： + +- **Java Development Kit**（JDK 8 以上）がインストールされていること。 +- **IntelliJ IDEA** または **Eclipse** などの IDE があること。 +- インデックス対象のドキュメントが格納されたフォルダーが用意されていること。 +- 依存関係管理に Maven を使用する（または JAR を手動でダウンロード）。 + +### 必要なライブラリと依存関係 +Maven プロジェクトに GroupDocs.Search を追加します： + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +直接ダウンロードする場合は、[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) から最新バージョンを取得してください。 + +### 環境設定 +- **JAVA_HOME** が互換性のある JDK を指していることを確認します。 +- IDE でプロジェクトを作成し、上記の Maven 設定を追加します。 +- `documents/` などのディレクトリを用意し、サンプルのテキスト、PDF、Word ファイルを配置します。 + +## GroupDocs.Search for Java のセットアップ手順 +1. **ライブラリのインストール** – 上記の Maven スニペットを使用するか、[GroupDocs](https://releases.groupdocs.com/search/java/) から JAR をダウンロードします。 +2. **ライセンスの取得** – まずはトライアルライセンスを取得し、運用開始時に本ライセンスへアップグレードします。 +3. **インデックスの初期化** – 以下のスニペットはインデックスフォルダーを作成（または開く）方法を示しています： + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## **highlight search results Java** の実装 – 同期インデックス作成 +同期インデックスはドキュメントを即座に処理し、追加されたファイルをすぐに検索可能にします。 + +### 手順 1: インデックス作成とエラーハンドリングの設定 +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### 手順 2: ドキュメントの追加と検索実行 +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### 手順 3: 結果処理と **highlight search results Java** の実行 +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +`DocumentHighlighter` は一致した語句を自動的に `` タグ（または設定した任意の形式）でラップし、**ハイライトされた検索結果** を表示用に提供します。 + +## **highlight search results Java** の実装 – 非同期インデックス作成 +数千件のファイルを扱う場合、メインスレッドをブロックするのは望ましくありません。非同期インデックスはエンジンをバックグラウンドで動作させます。 + +### 手順 1: イベントリスナー付きインデックスの設定 +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### 手順 2: 非同期モードを有効化してインデックス作成開始 +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +インデックス構築中でもアプリケーションは他のリクエストを処理し続けられます。`StatusChanged` イベントが `Ready` を報告したら、安全に検索を実行し、**highlight search results Java** を取得できます。 + +## **index documents java** の実践的ヒント +- **バッチサイズ**: 大規模コレクションの場合、フォルダーを小さなバッチに分割してメモリスパイクを防止します。 +- **ファイルフィルター**: `IndexingOptions.setFileExtensions` を使用し、必要な形式（例: `.pdf`, `.docx`）だけを対象にします。 +- **再インデックス**: ドキュメントが変更されたときは、インデックス全体を再構築するのではなく `index.update(documentPath)` を呼び出します。 + +## パフォーマンス考慮事項 +- **メモリ**: ヒープ使用量に注意し、 大量の大きなファイルを処理する場合は `-Xmx` を増やします。 +- **CPU**: 非同期インデックスは負荷を分散しますが CPU を消費します。JVisualVM で監視してください。 +- **結果ハイライト**: ハイライト処理にはわずかなオーバーヘッドが発生します。結果を頻繁に表示する場合は生成された HTML をキャッシュすると効果的です。 + +## よくある質問 + +**Q: 同期インデックスと非同期インデックスを同一アプリケーションで併用できますか？** +A: はい。小規模で頻繁に更新されるデータは同期インデックス、バルクインポートやバックグラウンドジョブは非同期インデックスで使い分けます。 + +**Q: ハイライトのスタイルはどうカスタマイズしますか？** +A: 一致した語句の周囲に任意の HTML、CSS、XML タグを書き込むカスタム `DocumentHighlighter` 実装を提供してください。 + +**Q: GroupDocs.Search が標準でサポートしているファイルタイプは？** +A: テキスト、PDF、DOC/DOCX、XLS/XLSX、PPT/PPTX、HTML など多数。組み込みパーサーによりさらに多くの形式を処理できます。 + +**Q: 複数言語を同時に検索できますか？** +A: 可能です。インデックス作成時に適切な `Analyzer` を設定すれば、マルチランゲージ検索が利用できます。 + +**Q: インデックスフォルダーのセキュリティはどう確保すればよいですか？** +A: 保護されたディレクトリにインデックスを保存し、ファイルシステムのアクセス権を適切に設定します。また、ライブラリのセキュリティ機能を使用してインデックスを暗号化することも検討してください。 + +--- + +**最終更新日:** 2026-02-08 +**テスト環境:** GroupDocs.Search 25.4 for Java +**作者:** GroupDocs \ No newline at end of file diff --git a/content/korean/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/korean/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..eac50d6a --- /dev/null +++ b/content/korean/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,239 @@ +--- +date: '2026-02-08' +description: Java에서 검색 결과를 강조 표시하는 방법과 GroupDocs.Search for Java를 사용한 동기 및 비동기 인덱싱으로 + 문서를 인덱싱하는 방법을 배워보세요. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: 검색 결과 하이라이트 Java – 동기 및 비동기 인덱싱 +type: docs +url: /ko/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + + translation. + +Let's produce Korean version. + +Be careful with bold **text** keep formatting. + +Let's translate. + +Start: + +# Highlight Search Results Java – Synchronous & Async Indexing + +Translate heading: "Highlight Search Results Java – Synchronous & Async Indexing" maybe keep as is but Korean translation: "Java 하이라이트 검색 결과 – 동기 및 비동기 인덱싱". Keep "Highlight Search Results Java" maybe keep phrase? The phrase is technical term, but we can translate partially. Keep "Highlight Search Results Java" maybe keep as is? The instruction: translate all text naturally, keep technical terms in English. "highlight search results Java" is a phrase; maybe keep as is? It is a term. Could translate "highlight search results Java" as is? I'd keep the phrase unchanged to avoid breaking meaning. But heading includes that phrase. Could translate rest: "# Highlight Search Results Java – Synchronous & Async Indexing" -> "# Highlight Search Results Java – 동기 및 비동기 인덱싱". Keep "Highlight Search Results Java" unchanged. + +Proceed similarly. + +Let's craft translation. + +# Highlight Search Results Java – 동기 및 비동기 인덱싱 + +Boost your Java applications by **highlighting search results Java** with the powerful GroupDocs.Search library. Whether you’re dealing with a few files or a massive repository, mastering both synchronous and asynchronous indexing lets you deliver fast, accurate results without blocking your application threads. + +## 빠른 답변 +- **“highlight search results Java”가 의미하는 것은?** 검색 결과에서 일치하는 용어를 시각적 표시(예: HTML `` 태그)로 렌더링하여 사용자가 각 문서에서 쿼리가 나타나는 위치를 확인할 수 있게 하는 것입니다. +- **동기 인덱싱을 언제 사용해야 하나요?** 새로 추가된 문서를 즉시 사용할 수 있어야 하는 소규모~중규모 데이터 세트에 적합합니다. +- **비동기 인덱싱이 더 좋은 경우는?** 대용량 문서 컬렉션을 처리하거나 UI 스레드에서 애플리케이션을 응답 상태로 유지해야 할 때 사용합니다. +- **라이선스가 필요합니까?** 개발용으로는 무료 체험판을 사용할 수 있으며, 정식 라이선스를 구매하면 고급 기능이 활성화되고 사용 제한이 해제됩니다. +- **지원되는 Java 버전은?** Java 8 이상. + +## “highlight search results Java”란? +Highlighting search results in Java means taking the raw matches returned by GroupDocs.Search and wrapping the matching terms in HTML (or another markup) so they stand out when displayed in a UI or web page. This improves user experience by instantly showing the context of each hit. + +## 왜 Java용 GroupDocs.Search를 사용하나요? +GroupDocs.Search provides a high‑performance, language‑agnostic engine that supports: +- Real‑time indexing and searching +- Asynchronous processing for large workloads +- Built‑in result highlighting +- Multi‑language and custom analyzer support + +These capabilities make it ideal for content management systems, e‑commerce catalogs, and enterprise document repositories. + +## 사전 요구 사항 +시작하기 전에 다음이 준비되어 있는지 확인하세요: + +- **Java Development Kit** (JDK 8 이상) 설치 +- **IntelliJ IDEA** 또는 **Eclipse** 같은 IDE +- 인덱싱하려는 문서가 들어 있는 폴더 +- Maven을 이용한 의존성 관리 (또는 JAR를 직접 다운로드) + +### 필수 라이브러리 및 의존성 +Maven 프로젝트에 GroupDocs.Search를 추가합니다: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +직접 다운로드하려면 최신 버전을 [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/)에서 받으세요. + +### 환경 설정 +- **JAVA_HOME**가 호환 가능한 JDK를 가리키는지 확인 +- IDE에서 프로젝트를 생성하고 위 Maven 설정을 추가 +- 예시 텍스트, PDF, Word 파일이 들어 있는 디렉터리(예: `documents/`)를 준비 + +## GroupDocs.Search for Java 설정 방법 +1. **라이브러리 설치** – 위 Maven 스니펫을 사용하거나 [GroupDocs](https://releases.groupdocs.com/search/java/)에서 JAR를 다운로드합니다. +2. **라이선스 획득** – 먼저 체험 라이선스로 시작하고, 프로덕션 환경에서는 정식 라이선스로 업그레이드합니다. +3. **인덱스 초기화** – 다음 스니펫은 인덱스 폴더를 생성(또는 열기)하는 방법을 보여줍니다: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## Highlight Search Results Java – 동기 인덱싱 +동기 인덱싱은 문서를 즉시 처리하여 새로 추가된 파일을 바로 검색할 수 있게 합니다. + +### 단계 1: 인덱스 생성 및 오류 처리 연결 +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### 단계 2: 문서 추가 및 검색 실행 +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### 단계 3: 결과 처리 및 **highlight search results Java** 수행 +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +`DocumentHighlighter`가 자동으로 일치하는 용어를 `` 태그(또는 사용자가 지정한 형식)로 감싸 **highlighted search results**를 바로 표시할 수 있게 합니다. + +## Highlight Search Results Java – 비동기 인덱싱 +수천 개의 파일을 다룰 때 메인 스레드를 차단하면 안 됩니다. 비동기 인덱싱을 사용하면 엔진이 백그라운드에서 작업합니다. + +### 단계 1: 이벤트 리스너와 함께 인덱스 설정 +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### 단계 2: 비동기 모드 활성화 및 인덱싱 시작 +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +인덱스가 구축되는 동안 애플리케이션은 다른 요청을 계속 처리할 수 있습니다. `StatusChanged` 이벤트가 `Ready`를 보고하면 안전하게 검색을 실행하고 **highlighted search results Java**를 얻을 수 있습니다. + +## **index documents java** – 실용 팁 +- **배치 크기**: 대용량 컬렉션은 메모리 급증을 방지하기 위해 폴더를 작은 배치로 나눕니다. +- **파일 필터**: `IndexingOptions.setFileExtensions`를 사용해 필요한 형식(.pdf, .docx 등)만 포함시킵니다. +- **재인덱싱**: 문서가 변경되면 전체 인덱스를 다시 만들지 말고 `index.update(documentPath)`를 호출합니다. + +## 성능 고려 사항 +- **메모리**: 힙 사용량을 모니터링하고, 많은 대용량 파일을 처리할 경우 `-Xmx` 옵션을 늘립니다. +- **CPU**: 비동기 인덱싱은 워크로드를 분산시키지만 여전히 CPU를 사용하므로 JVisualVM 등으로 모니터링합니다. +- **결과 하이라이팅**: 하이라이팅은 약간의 추가 처리 비용이 발생합니다. 결과를 반복적으로 표시해야 한다면 생성된 HTML을 캐시하세요. + +## 자주 묻는 질문 + +**Q: 동기와 비동기 인덱싱을 같은 애플리케이션에서 함께 사용할 수 있나요?** +A: 네. 소규모이면서 자주 업데이트되는 세트는 동기 인덱싱을, 대량 임포트나 백그라운드 작업은 비동기 인덱싱을 사용하면 됩니다. + +**Q: 하이라이트 스타일을 어떻게 커스터마이즈하나요?** +A: 일치하는 용어 주위에 원하는 HTML, CSS, XML 태그를 삽입하는 `DocumentHighlighter` 구현을 제공하면 됩니다. + +**Q: GroupDocs.Search가 기본적으로 지원하는 파일 유형은 무엇인가요?** +A: 텍스트, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML 등 다양한 형식을 내장 파서로 지원합니다. + +**Q: 여러 언어를 동시에 검색할 수 있나요?** +A: 가능합니다. 인덱스를 생성할 때 적절한 `Analyzer`를 설정하면 다국어 분석기가 적용됩니다. + +**Q: 인덱스 폴더를 어떻게 보호하나요?** +A: 인덱스를 보호된 디렉터리에 저장하고 파일 시스템 권한을 적절히 설정하세요. 또한 라이브러리의 보안 기능을 사용해 인덱스를 암호화하는 것도 고려해 보세요. + +--- + +**마지막 업데이트:** 2026-02-08 +**테스트 환경:** GroupDocs.Search 25.4 for Java +**작성자:** GroupDocs \ No newline at end of file diff --git a/content/polish/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/polish/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..b4106cbf --- /dev/null +++ b/content/polish/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,220 @@ +--- +date: '2026-02-08' +description: Dowiedz się, jak podświetlać wyniki wyszukiwania w Javie oraz jak indeksować + dokumenty w Javie przy użyciu GroupDocs.Search for Java z indeksowaniem synchronicznym + i asynchronicznym. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Podświetlanie wyników wyszukiwania w Javie – indeksowanie synchroniczne i asynchroniczne +type: docs +url: /pl/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Highlight Search Results Java – indeksowanie synchroniczne i asynchroniczne + +Zwiększ wydajność swoich aplikacji Java, **highlighting search results Java** dzięki potężnej bibliotece GroupDocs.Search. Niezależnie od tego, czy pracujesz z kilkoma plikami, czy z ogromnym repozytorium, opanowanie zarówno synchronicznego, jak i asynchronicznego indeksowania pozwala dostarczać szybkie, dokładne wyniki bez blokowania wątków aplikacji. + +## Quick Answers +- **Co oznacza „highlight search results Java”?** Odnosi się do renderowania dopasowanych terminów w wynikach wyszukiwania przy użyciu wskazówek wizualnych (np. tagów HTML ``), aby użytkownicy mogli zobaczyć, gdzie zapytanie pojawia się w każdym dokumencie. +- **Kiedy powinienem używać indeksowania synchronicznego?** Dla małych i średnich zbiorów danych, gdzie wymagana jest natychmiastowa dostępność nowo dodanych dokumentów. +- **Kiedy indeksowanie asynchroniczne jest preferowane?** Podczas przetwarzania dużych kolekcji dokumentów lub uruchamiania na wątku UI, gdzie trzeba utrzymać responsywność aplikacji. +- **Czy potrzebna jest licencja?** Darmowa wersja próbna wystarcza do rozwoju; pełna licencja odblokowuje zaawansowane funkcje i usuwa limity użytkowania. +- **Jaką wersję Java obsługuje się?** Java 8 lub nowsza. + +## Co to jest „highlight search results Java”? +Wyróżnianie wyników wyszukiwania w Javie oznacza pobranie surowych dopasowań zwróconych przez GroupDocs.Search i otoczenie dopasowanych terminów znacznikami HTML (lub innym formatowaniem), aby wyróżniały się przy wyświetlaniu w interfejsie użytkownika lub na stronie internetowej. Poprawia to doświadczenie użytkownika, natychmiast pokazując kontekst każdego trafienia. + +## Why use GroupDocs.Search for Java? +GroupDocs.Search provides a high‑performance, language‑agnostic engine that supports: +- Indeksowanie i wyszukiwanie w czasie rzeczywistym +- Przetwarzanie asynchroniczne dla dużych obciążeń +- Wbudowane wyróżnianie wyników +- Obsługa wielu języków i własnych analizatorów + +These capabilities make it ideal for content management systems, e‑commerce catalogs, and enterprise document repositories. + +## Wymagania wstępne +- **Java Development Kit** (JDK 8 lub nowszy) zainstalowany. +- IDE, takie jak **IntelliJ IDEA** lub **Eclipse**. +- Folder zawierający dokumenty, które chcesz zindeksować. +- Maven do zarządzania zależnościami (lub możesz pobrać plik JAR ręcznie). + +### Required Libraries and Dependencies +Add GroupDocs.Search to your Maven project: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +For direct downloads, get the latest version from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Environment Setup +- Sprawdź, czy **JAVA_HOME** wskazuje na kompatybilny JDK. +- Utwórz projekt w swoim IDE i dodaj powyższą konfigurację Maven. +- Przygotuj katalog (np. `documents/`) z przykładowymi plikami tekstowymi, PDF lub Word. + +## How to set up GroupDocs.Search for Java +1. **Zainstaluj bibliotekę** – użyj fragmentu Maven podanego powyżej lub pobierz plik JAR z [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Uzyskaj licencję** – rozpocznij od licencji próbnej, a następnie przejdź na pełną wersję przy wdrożeniu produkcyjnym. +3. **Zainicjuj indeks** – poniższy fragment pokazuje, jak utworzyć (lub otworzyć) folder indeksu: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## Jak wyróżniać wyniki wyszukiwania Java – indeksowanie synchroniczne +Indeksowanie synchroniczne przetwarza dokumenty natychmiast, dzięki czemu nowo dodane pliki są od razu dostępne do wyszukiwania. + +### Krok 1: Utwórz indeks i podłącz obsługę błędów +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Krok 2: Dodaj dokumenty i uruchom wyszukiwanie +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Krok 3: Przetwórz wyniki i **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +`DocumentHighlighter` automatycznie otacza dopasowane terminy tagami `` (lub dowolnym formatem, który skonfigurujesz), dostarczając **highlighted search results** gotowe do wyświetlenia. + +## Jak wyróżniać wyniki wyszukiwania Java – indeksowanie asynchroniczne +Podczas pracy z tysiącami plików blokowanie głównego wątku jest niepożądane. Indeksowanie asynchroniczne pozwala silnikowi działać w tle. + +### Krok 1: Skonfiguruj indeks z nasłuchiwaczami zdarzeń +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Krok 2: Włącz tryb asynchroniczny i rozpocznij indeksowanie +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +Podczas budowania indeksu aplikacja może obsługiwać inne żądania. Gdy zdarzenie `StatusChanged` zgłosi `Ready`, możesz bezpiecznie wykonywać wyszukiwania i uzyskać **highlighted search results Java**. + +## Jak **index documents java** – praktyczne wskazówki +- **Rozmiar partii**: dla ogromnych kolekcji podziel folder na mniejsze partie, aby uniknąć skoków pamięci. +- **Filtry plików**: użyj `IndexingOptions.setFileExtensions`, aby uwzględnić tylko potrzebne formaty (np. `.pdf`, `.docx`). +- **Reindeksowanie**: gdy dokumenty się zmieniają, wywołaj `index.update(documentPath)` zamiast przebudowywać cały indeks. + +## Rozważania dotyczące wydajności +- **Pamięć**: monitoruj zużycie sterty; zwiększ `-Xmx`, jeśli przetwarzasz wiele dużych plików. +- **CPU**: indeksowanie asynchroniczne rozkłada obciążenie, ale nadal zużywa CPU — monitoruj za pomocą JVisualVM. +- **Wyróżnianie wyników**: wyróżnianie dodaje niewielki narzut przetwarzania; buforuj wygenerowany HTML, jeśli musisz wielokrotnie wyświetlać wyniki. + +## Najczęściej zadawane pytania + +**P: Czy mogę łączyć indeksowanie synchroniczne i asynchroniczne w tej samej aplikacji?** +O: Tak. Używaj indeksowania synchronicznego dla małych, często aktualizowanych zestawów oraz indeksowania asynchronicznego dla importu hurtowego lub zadań w tle. + +**P: Jak dostosować styl wyróżniania?** +O: Dostarcz własną implementację `DocumentHighlighter`, która zapisuje pożądane tagi HTML, CSS lub XML wokół dopasowanych terminów. + +**P: Jakie typy plików obsługuje GroupDocs.Search domyślnie?** +O: Tekst, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML oraz wiele innych dzięki wbudowanym parserom. + +**P: Czy można wyszukiwać w wielu językach jednocześnie?** +O: Oczywiście. GroupDocs.Search zawiera analizatory wielojęzyczne; wystarczy skonfigurować odpowiedni `Analyzer` przy tworzeniu indeksu. + +**P: Jak zabezpieczyć folder indeksu?** +O: Przechowuj indeks w chronionym katalogu, ustaw odpowiednie uprawnienia systemu plików i rozważ szyfrowanie indeksu przy użyciu funkcji bezpieczeństwa biblioteki. + +--- + +**Ostatnia aktualizacja:** 2026-02-08 +**Testowano z:** GroupDocs.Search 25.4 for Java +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/portuguese/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/portuguese/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..db20dec5 --- /dev/null +++ b/content/portuguese/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,221 @@ +--- +date: '2026-02-08' +description: Aprenda como destacar resultados de pesquisa em Java e como indexar documentos + Java usando o GroupDocs.Search para Java com indexação síncrona e assíncrona. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Destaque de Resultados de Busca Java – Indexação Síncrona e Assíncrona +type: docs +url: /pt/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Realce de Resultados de Busca Java – Indexação Síncrona e Assíncrona + +Aumente suas aplicações Java usando **realce de resultados de busca Java** com a poderosa biblioteca GroupDocs.Search. Seja você lidando com alguns arquivos ou um repositório massivo, dominar tanto a indexação síncrona quanto a assíncrona permite entregar resultados rápidos e precisos sem bloquear as threads da sua aplicação. + +## Respostas Rápidas +- **O que significa “highlight search results Java”?** Refere‑se à renderização dos termos correspondentes nos resultados de busca com indicações visuais (por exemplo, tags HTML ``) para que os usuários vejam onde a consulta aparece em cada documento. +- **Quando devo usar indexação síncrona?** Para conjuntos de dados pequenos a médios onde a disponibilidade imediata dos documentos recém‑adicionados é necessária. +- **Quando a indexação assíncrona é preferível?** Ao processar grandes coleções de documentos ou ao executar em uma thread de UI onde é preciso manter a aplicação responsiva. +- **Preciso de uma licença?** Um teste gratuito funciona para desenvolvimento; uma licença completa desbloqueia recursos avançados e remove limites de uso. +- **Qual versão do Java é suportada?** Java 8 ou posterior. + +## O que é “highlight search results Java”? +Realçar resultados de busca em Java significa pegar as correspondências brutas retornadas pelo GroupDocs.Search e envolver os termos correspondentes em HTML (ou outra marcação) para que se destaquem quando exibidos em uma UI ou página web. Isso melhora a experiência do usuário ao mostrar instantaneamente o contexto de cada ocorrência. + +## Por que usar GroupDocs.Search para Java? +GroupDocs.Search fornece um mecanismo de alto desempenho, independente de idioma, que suporta: +- Indexação e busca em tempo real +- Processamento assíncrono para cargas de trabalho grandes +- Realce de resultados embutido +- Suporte a múltiplos idiomas e analisadores personalizados + +Essas capacidades tornam a ferramenta ideal para sistemas de gerenciamento de conteúdo, catálogos de e‑commerce e repositórios corporativos de documentos. + +## Pré‑requisitos +Antes de começar, certifique‑se de que você tem: + +- **Java Development Kit** (JDK 8 ou mais recente) instalado. +- Um IDE como **IntelliJ IDEA** ou **Eclipse**. +- Uma pasta contendo os documentos que você deseja indexar. +- Maven para gerenciamento de dependências (ou você pode baixar o JAR manualmente). + +### Bibliotecas e Dependências Necessárias +Adicione GroupDocs.Search ao seu projeto Maven: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Para downloads diretos, obtenha a versão mais recente em [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Configuração do Ambiente +- Verifique se seu **JAVA_HOME** aponta para um JDK compatível. +- Crie um projeto em seu IDE e adicione a configuração Maven acima. +- Prepare um diretório (por exemplo, `documents/`) com arquivos de texto, PDF ou Word de exemplo. + +## Como configurar o GroupDocs.Search para Java +1. **Instalar a Biblioteca** – Use o trecho Maven acima ou baixe o JAR em [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Obter uma Licença** – Comece com uma licença de avaliação, depois faça upgrade quando passar para produção. +3. **Inicializar o Índice** – O trecho a seguir mostra como criar (ou abrir) uma pasta de índice: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## Como realçar resultados de busca Java – Indexação Síncrona +A indexação síncrona processa documentos imediatamente, tornando os arquivos recém‑adicionados pesquisáveis de imediato. + +### Etapa 1: Criar o índice e anexar tratamento de erros +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Etapa 2: Adicionar documentos e executar uma busca +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Etapa 3: Processar resultados e **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +O `DocumentHighlighter` envolve automaticamente os termos correspondentes com tags `` (ou qualquer formato que você configure), fornecendo **highlighted search results** prontos para exibição. + +## Como realçar resultados de busca Java – Indexação Assíncrona +Ao lidar com milhares de arquivos, bloquear a thread principal é indesejável. A indexação assíncrona permite que o mecanismo trabalhe em segundo plano. + +### Etapa 1: Configurar o índice com ouvintes de eventos +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Etapa 2: Habilitar modo assíncrono e iniciar a indexação +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +Enquanto o índice está sendo construído, sua aplicação pode continuar atendendo a outras solicitações. Quando o evento `StatusChanged` reportar `Ready`, você pode executar buscas com segurança e obter **highlighted search results Java**. + +## Como **index documents java** – Dicas Práticas +- **Batch size**: Para coleções enormes, divida a pasta em lotes menores para evitar picos de memória. +- **File filters**: Use `IndexingOptions.setFileExtensions` para incluir apenas os formatos necessários (por exemplo, `.pdf`, `.docx`). +- **Re‑indexing**: Quando os documentos mudarem, chame `index.update(documentPath)` em vez de reconstruir todo o índice. + +## Considerações de Desempenho +- **Memory**: Fique de olho no uso de heap; aumente `-Xmx` se processar muitos arquivos grandes. +- **CPU**: A indexação assíncrona distribui a carga de trabalho, mas ainda consome CPU — monitore com JVisualVM. +- **Result Highlighting**: O realce adiciona uma pequena sobrecarga de processamento; faça cache do HTML gerado se precisar exibir resultados repetidamente. + +## Perguntas Frequentes + +**Q: Posso combinar indexação síncrona e assíncrona na mesma aplicação?** +A: Sim. Use indexação síncrona para conjuntos pequenos, frequentemente atualizados, e indexação assíncrona para importações em massa ou jobs em segundo plano. + +**Q: Como personalizo o estilo de realce?** +A: Forneça uma implementação personalizada de `DocumentHighlighter` que escreva as tags HTML, CSS ou XML desejadas ao redor dos termos correspondentes. + +**Q: Quais tipos de arquivo o GroupDocs.Search suporta nativamente?** +A: Texto, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML e muitos outros via seus analisadores integrados. + +**Q: É possível buscar em múltiplos idiomas simultaneamente?** +A: Absolutamente. O GroupDocs.Search inclui analisadores multilíngues; basta configurar o `Analyzer` apropriado ao criar o índice. + +**Q: Como protejo a pasta de índice?** +A: Armazene o índice em um diretório protegido, defina permissões adequadas no sistema de arquivos e considere criptografar o índice com os recursos de segurança da biblioteca. + +--- + +**Última Atualização:** 2026-02-08 +**Testado com:** GroupDocs.Search 25.4 for Java +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/russian/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/russian/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..770a4cee --- /dev/null +++ b/content/russian/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,220 @@ +--- +date: '2026-02-08' +description: Узнайте, как подсвечивать результаты поиска в Java и как индексировать + документы Java с помощью GroupDocs.Search for Java, используя синхронную и асинхронную + индексацию. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Подсветка результатов поиска Java – Синхронная и асинхронная индексация +type: docs +url: /ru/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Выделение результатов поиска Java – Синхронная и Асинхронная индексация + +Улучшите свои Java‑приложения, **выделяя результаты поиска Java** с помощью мощной библиотеки GroupDocs.Search. Независимо от того, работаете ли вы с несколькими файлами или с огромным репозиторием, освоение как синхронной, так и асинхронной индексации позволяет предоставлять быстрые, точные результаты без блокировки потоков вашего приложения. + +## Быстрые ответы +- **Что означает “highlight search results Java”?** Это отображение найденных терминов в результатах поиска с визуальными подсказками (например, HTML `` тегами), чтобы пользователи могли видеть, где запрос встречается в каждом документе. +- **Когда следует использовать синхронную индексацию?** Для небольших и средних наборов данных, где требуется мгновенная доступность только что добавленных документов. +- **Когда предпочтительна асинхронная индексация?** При обработке больших коллекций документов или работе в UI‑потоке, где необходимо сохранять отзывчивость приложения. +- **Нужна ли лицензия?** Бесплатная пробная версия подходит для разработки; полная лицензия открывает расширенные функции и снимает ограничения по использованию. +- **Какая версия Java поддерживается?** Java 8 или новее. + +## Что такое “highlight search results Java”? +Выделение результатов поиска в Java означает взятие необработанных совпадений, возвращаемых GroupDocs.Search, и оборачивание найденных терминов в HTML (или другую разметку), чтобы они выделялись при отображении в пользовательском интерфейсе или веб‑странице. Это улучшает пользовательский опыт, мгновенно показывая контекст каждого совпадения. + +## Почему использовать GroupDocs.Search для Java? +GroupDocs.Search предоставляет высокопроизводительный, независимый от языка движок, который поддерживает: +- Индексацию и поиск в реальном времени +- Асинхронную обработку больших нагрузок +- Встроенное выделение результатов +- Поддержку многоязычных и пользовательских анализаторов + +## Предварительные требования +Перед началом убедитесь, что у вас есть: + +- **Java Development Kit** (JDK 8 или новее) установлен. +- IDE, например **IntelliJ IDEA** или **Eclipse**. +- Папка, содержащая документы, которые вы хотите проиндексировать. +- Maven для управления зависимостями (или вы можете скачать JAR вручную). + +### Требуемые библиотеки и зависимости +Добавьте GroupDocs.Search в ваш Maven‑проект: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Для прямой загрузки получите последнюю версию по ссылке [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Настройка окружения +- Проверьте, что переменная **JAVA_HOME** указывает на совместимый JDK. +- Создайте проект в вашей IDE и добавьте вышеуказанную конфигурацию Maven. +- Подготовьте каталог (например, `documents/`) с образцами текстовых, PDF‑ или Word‑файлов. + +## Как настроить GroupDocs.Search для Java +1. **Установить библиотеку** – Используйте фрагмент Maven выше или скачайте JAR с [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Получить лицензию** – Начните с пробной лицензии, затем перейдите на полную при переходе в продакшн. +3. **Инициализировать индекс** – Ниже приведён фрагмент, показывающий, как создать (или открыть) папку индекса: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## Как выделять результаты поиска Java – Синхронная индексация +Синхронная индексация обрабатывает документы сразу, делая только что добавленные файлы доступными для поиска немедленно. + +### Шаг 1: Создать индекс и добавить обработку ошибок +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Шаг 2: Добавить документы и выполнить поиск +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Шаг 3: Обработать результаты и **выделять результаты поиска Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +`DocumentHighlighter` автоматически оборачивает найденные термины в теги `` (или любой другой формат, который вы настроите), предоставляя **выделенные результаты поиска**, готовые к отображению. + +## Как выделять результаты поиска Java – Асинхронная индексация +При работе с тысячами файлов блокировка основного потока нежелательна. Асинхронная индексация позволяет движку работать в фоновом режиме. + +### Шаг 1: Настроить индекс с обработчиками событий +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Шаг 2: Включить асинхронный режим и начать индексацию +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +Пока индекс строится, ваше приложение может продолжать обслуживать другие запросы. Как только событие `StatusChanged` сообщает `Ready`, вы можете безопасно выполнять поиск и получать **выделенные результаты поиска Java**. + +## Как **индексировать документы java** – Практические советы +- **Размер пакета**: Для огромных коллекций разбивайте папку на более мелкие пакеты, чтобы избежать всплесков памяти. +- **Фильтры файлов**: Используйте `IndexingOptions.setFileExtensions`, чтобы включать только необходимые форматы (например, `.pdf`, `.docx`). +- **Переиндексация**: Когда документы меняются, вызывайте `index.update(documentPath)` вместо полной перестройки индекса. + +## Соображения по производительности +- **Память**: Следите за использованием кучи; увеличьте `-Xmx`, если обрабатываете много больших файлов. +- **CPU**: Асинхронная индексация распределяет нагрузку, но всё равно потребляет процессор — контролируйте её с помощью JVisualVM. +- **Выделение результатов**: Выделение добавляет небольшие накладные расходы; кэшируйте сгенерированный HTML, если нужно многократно отображать результаты. + +## Часто задаваемые вопросы + +**В: Можно ли комбинировать синхронную и асинхронную индексацию в одном приложении?** +О: Да. Используйте синхронную индексацию для небольших часто обновляемых наборов и асинхронную индексацию для массового импорта или фоновых задач. + +**В: Как настроить стиль выделения?** +О: Предоставьте собственную реализацию `DocumentHighlighter`, которая записывает нужные HTML, CSS или XML‑теги вокруг найденных терминов. + +**В: Какие типы файлов поддерживает GroupDocs.Search из коробки?** +О: Текстовые, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML и многие другие через встроенные парсеры. + +**В: Можно ли выполнять поиск сразу по нескольким языкам?** +О: Конечно. GroupDocs.Search включает многоязычные анализаторы; просто настройте соответствующий `Analyzer` при создании индекса. + +**В: Как защитить папку индекса?** +О: Храните индекс в защищённом каталоге, задайте правильные разрешения файловой системы и рассмотрите возможность шифрования индекса с помощью функций безопасности библиотеки. + +--- + +**Последнее обновление:** 2026-02-08 +**Тестировано с:** GroupDocs.Search 25.4 for Java +**Автор:** GroupDocs \ No newline at end of file diff --git a/content/spanish/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/spanish/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..392183ab --- /dev/null +++ b/content/spanish/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,221 @@ +--- +date: '2026-02-08' +description: Aprenda cómo resaltar resultados de búsqueda en Java y cómo indexar documentos + en Java usando GroupDocs.Search para Java con indexación sincrónica y asincrónica. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Resaltar resultados de búsqueda Java – Indexación sincrónica y asíncrona +type: docs +url: /es/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Resaltar resultados de búsqueda Java – Indexación sincrónica y asíncrona + +Impulsa tus aplicaciones Java resaltando los resultados de búsqueda con la potente biblioteca GroupDocs.Search. Ya sea que trabajes con unos pocos archivos o con un repositorio masivo, dominar tanto la indexación sincrónica como la asíncrona te permite ofrecer resultados rápidos y precisos sin bloquear los hilos de tu aplicación. + +## Respuestas rápidas +- **¿Qué significa “highlight search results Java”?** Se refiere a renderizar los términos coincidentes en los resultados de búsqueda con indicadores visuales (p. ej., etiquetas HTML ``) para que los usuarios vean dónde aparece la consulta en cada documento. +- **¿Cuándo debo usar la indexación sincrónica?** Para conjuntos de datos pequeños a medianos donde se requiere disponibilidad inmediata de los documentos recién agregados. +- **¿Cuándo es preferible la indexación asíncrona?** Al procesar colecciones grandes de documentos o ejecutar en un hilo de UI donde debes mantener la aplicación receptiva. +- **¿Necesito una licencia?** Una prueba gratuita funciona para desarrollo; una licencia completa desbloquea funciones avanzadas y elimina los límites de uso. +- **¿Qué versión de Java es compatible?** Java 8 o posterior. + +## ¿Qué es “highlight search results Java”? +Resaltar los resultados de búsqueda en Java significa tomar las coincidencias crudas devueltas por GroupDocs.Search y envolver los términos coincidentes en HTML (u otro marcado) para que destaquen cuando se muestren en una interfaz o página web. Esto mejora la experiencia del usuario al mostrar instantáneamente el contexto de cada hallazgo. + +## ¿Por qué usar GroupDocs.Search para Java? +GroupDocs.Search ofrece un motor de alto rendimiento, independiente del lenguaje, que soporta: +- Indexación y búsqueda en tiempo real +- Procesamiento asíncrono para cargas de trabajo grandes +- Resaltado de resultados incorporado +- Soporte multilingüe y de analizadores personalizados + +Estas capacidades lo hacen ideal para sistemas de gestión de contenido, catálogos de comercio electrónico y repositorios empresariales de documentos. + +## Requisitos previos +Antes de comenzar, asegúrate de tener: + +- **Java Development Kit** (JDK 8 o más reciente) instalado. +- Un IDE como **IntelliJ IDEA** o **Eclipse**. +- Una carpeta que contenga los documentos que deseas indexar. +- Maven para la gestión de dependencias (o puedes descargar el JAR manualmente). + +### Bibliotecas y dependencias requeridas +Agrega GroupDocs.Search a tu proyecto Maven: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Para descargas directas, obtén la última versión en [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Configuración del entorno +- Verifica que tu **JAVA_HOME** apunte a un JDK compatible. +- Crea un proyecto en tu IDE y añade la configuración Maven anterior. +- Prepara un directorio (p. ej., `documents/`) con archivos de texto, PDF o Word de ejemplo. + +## Cómo configurar GroupDocs.Search para Java +1. **Instalar la biblioteca** – Usa el fragmento Maven anterior o descarga el JAR desde [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Obtener una licencia** – Comienza con una licencia de prueba y luego actualiza cuando pases a producción. +3. **Inicializar el índice** – El siguiente fragmento muestra cómo crear (o abrir) una carpeta de índice: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## Cómo resaltar resultados de búsqueda Java – Indexación sincrónica +La indexación sincrónica procesa los documentos de inmediato, haciendo que los archivos recién agregados sean buscables al instante. + +### Paso 1: Crear el índice y adjuntar el manejo de errores +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Paso 2: Añadir documentos y ejecutar una búsqueda +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Paso 3: Procesar los resultados y **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +El `DocumentHighlighter` envuelve automáticamente los términos coincidentes con etiquetas `` (o cualquier formato que configures), proporcionando **resultados de búsqueda resaltados** listos para mostrarse. + +## Cómo resaltar resultados de búsqueda Java – Indexación asíncrona +Al trabajar con miles de archivos, bloquear el hilo principal es indeseable. La indexación asíncrona permite que el motor trabaje en segundo plano. + +### Paso 1: Configurar el índice con escuchas de eventos +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Paso 2: Habilitar el modo asíncrono e iniciar la indexación +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +Mientras se construye el índice, tu aplicación puede seguir atendiendo otras solicitudes. Una vez que el evento `StatusChanged` informe `Ready`, puedes ejecutar búsquedas de forma segura y obtener **highlighted search results Java**. + +## Cómo **index documents java** – Consejos prácticos +- **Tamaño de lote**: Para colecciones enormes, divide la carpeta en lotes más pequeños para evitar picos de memoria. +- **Filtros de archivo**: Usa `IndexingOptions.setFileExtensions` para incluir solo los formatos que necesites (p. ej., `.pdf`, `.docx`). +- **Re‑indexado**: Cuando los documentos cambien, llama a `index.update(documentPath)` en lugar de reconstruir todo el índice. + +## Consideraciones de rendimiento +- **Memoria**: Vigila el uso del heap; aumenta `-Xmx` si procesas muchos archivos grandes. +- **CPU**: La indexación asíncrona distribuye la carga, pero sigue consumiendo CPU—monitorea con JVisualVM. +- **Resaltado de resultados**: El resaltado añade una pequeña sobrecarga de procesamiento; almacena en caché el HTML generado si necesitas mostrar los resultados repetidamente. + +## Preguntas frecuentes + +**P: ¿Puedo combinar indexación sincrónica y asíncrona en la misma aplicación?** +R: Sí. Usa la indexación sincrónica para conjuntos pequeños y actualizados frecuentemente y la asíncrona para importaciones masivas o trabajos en segundo plano. + +**P: ¿Cómo personalizo el estilo del resaltado?** +R: Proporciona una implementación personalizada de `DocumentHighlighter` que escriba las etiquetas HTML, CSS o XML deseadas alrededor de los términos coincidentes. + +**P: ¿Qué tipos de archivo admite GroupDocs.Search de forma nativa?** +R: Texto, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML y muchos más mediante sus analizadores integrados. + +**P: ¿Es posible buscar en varios idiomas simultáneamente?** +R: Absolutamente. GroupDocs.Search incluye analizadores multilingües; solo configura el `Analyzer` apropiado al crear el índice. + +**P: ¿Cómo protejo la carpeta del índice?** +R: Almacena el índice en un directorio protegido, establece los permisos adecuados del sistema de archivos y considera cifrar el índice con las funciones de seguridad de la biblioteca. + +--- + +**Última actualización:** 2026-02-08 +**Probado con:** GroupDocs.Search 25.4 for Java +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/swedish/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/swedish/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..067432ee --- /dev/null +++ b/content/swedish/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,221 @@ +--- +date: '2026-02-08' +description: Lär dig hur du markerar sökresultat i Java och hur du indexerar dokument + i Java med GroupDocs.Search för Java med synkron och asynkron indexering. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Markera sökresultat Java – Synkron och asynkron indexering +type: docs +url: /sv/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Markera sökresultat Java – Synkron & Asynkron indexering + +Boosta dina Java‑applikationer genom **highlighting search results Java** med det kraftfulla GroupDocs.Search‑biblioteket. Oavsett om du hanterar några få filer eller ett massivt arkiv, låter dig behärskning av både synkron och asynkron indexering leverera snabba, exakta resultat utan att blockera dina applikationstrådar. + +## Snabba svar +- **Vad betyder “highlight search results Java”?** Det innebär att rendera matchande termer i sökresultaten med visuella ledtrådar (t.ex. HTML‑taggen ``) så att användarna kan se var frågan förekommer i varje dokument. +- **När bör jag använda synkron indexering?** För små till medelstora datamängder där omedelbar tillgänglighet av nyinlagda dokument krävs. +- **När är asynkron indexering att föredra?** När du bearbetar stora dokumentsamlingar eller kör på en UI‑tråd där du måste hålla applikationen responsiv. +- **Behöver jag en licens?** En gratis provversion fungerar för utveckling; en full licens låser upp avancerade funktioner och tar bort användningsgränser. +- **Vilken Java‑version stöds?** Java 8 eller senare. + +## Vad är “highlight search results Java”? +Att markera sökresultat i Java innebär att ta de råa matchningarna som returneras av GroupDocs.Search och omsluta de matchande termerna i HTML (eller annan markup) så att de framträder tydligt när de visas i ett UI eller på en webbsida. Detta förbättrar användarupplevelsen genom att omedelbart visa kontexten för varje träff. + +## Varför använda GroupDocs.Search för Java? +GroupDocs.Search erbjuder en högpresterande, språk‑agnostisk motor som stödjer: +- Realtids‑indexering och sökning +- Asynkron bearbetning för stora arbetsbelastningar +- Inbyggd resultatmarkering +- Stöd för flera språk och anpassade analysatorer + +Dessa funktioner gör den idealisk för innehållshanteringssystem, e‑handelskataloger och företagsdokumentarkiv. + +## Förutsättningar +Innan du börjar, se till att du har: + +- **Java Development Kit** (JDK 8 eller nyare) installerat. +- En IDE såsom **IntelliJ IDEA** eller **Eclipse**. +- En mapp som innehåller de dokument du vill indexera. +- Maven för beroendehantering (eller så kan du ladda ner JAR‑filen manuellt). + +### Nödvändiga bibliotek och beroenden +Lägg till GroupDocs.Search i ditt Maven‑projekt: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +För direkta nedladdningar, hämta den senaste versionen från [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Miljöinställning +- Verifiera att din **JAVA_HOME** pekar på en kompatibel JDK. +- Skapa ett projekt i din IDE och lägg till Maven‑konfigurationen ovan. +- Förbered en katalog (t.ex. `documents/`) med exempel på text‑, PDF‑ eller Word‑filer. + +## Hur man konfigurerar GroupDocs.Search för Java +1. **Installera biblioteket** – Använd Maven‑snutten ovan eller ladda ner JAR‑filen från [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Skaffa en licens** – Börja med en provlicens, uppgradera sedan när du går i produktion. +3. **Initiera indexet** – Följande kodsnutt visar hur du skapar (eller öppnar) en indexmapp: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## Hur man markerar sökresultat Java – Synkron indexering +Synkron indexering bearbetar dokument omedelbart, så nyinlagda filer blir sökbara direkt. + +### Steg 1: Skapa indexet och lägg till felhantering +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Steg 2: Lägg till dokument och kör en sökning +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Steg 3: Bearbeta resultat och **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +`DocumentHighlighter` omsluter automatiskt matchande termer med ``‑taggar (eller vilket format du konfigurerar), vilket ger dig **highlighted search results** redo för visning. + +## Hur man markerar sökresultat Java – Asynkron indexering +När du hanterar tusentals filer är det oönskat att blockera huvudtråden. Asynkron indexering låter motorn arbeta i bakgrunden. + +### Steg 1: Konfigurera indexet med händelselyssnare +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Steg 2: Aktivera asynkront läge och starta indexering +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +Medan indexet byggs kan din applikation fortsätta att hantera andra förfrågningar. När `StatusChanged`‑händelsen rapporterar `Ready` kan du säkert köra sökningar och erhålla **highlighted search results Java**. + +## Hur man **indexerar dokument java** – Praktiska tips +- **Batch‑storlek**: För enorma samlingar, dela upp mappen i mindre batcher för att undvika minnesspikar. +- **Filtrering**: Använd `IndexingOptions.setFileExtensions` för att inkludera endast de format du behöver (t.ex. `.pdf`, `.docx`). +- **Re‑indexering**: När dokument ändras, anropa `index.update(documentPath)` istället för att bygga om hela indexet. + +## Prestandaöverväganden +- **Minne**: Håll ett öga på heap‑användningen; öka `-Xmx` om du bearbetar många stora filer. +- **CPU**: Asynkron indexering sprider arbetsbelastningen, men förbrukar fortfarande CPU—övervaka med JVisualVM. +- **Resultatmarkering**: Markering lägger till en liten bearbetningskostnad; cacha den genererade HTML‑koden om du behöver visa resultat upprepade gånger. + +## Vanliga frågor + +**Q: Kan jag kombinera synkron och asynkron indexering i samma applikation?** +A: Ja. Använd synkron indexering för små, ofta uppdaterade mängder och asynkron indexering för bulk‑import eller bakgrundsjobb. + +**Q: Hur anpassar jag markeringsstilen?** +A: Tillhandahåll en egen `DocumentHighlighter`‑implementation som skriver önskad HTML, CSS eller XML‑tagg runt matchande termer. + +**Q: Vilka filtyper stöder GroupDocs.Search direkt?** +A: Text, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML och många fler via dess inbyggda parsers. + +**Q: Är det möjligt att söka i flera språk samtidigt?** +A: Absolut. GroupDocs.Search innehåller flerspråkiga analysatorer; konfigurera bara rätt `Analyzer` när du skapar indexet. + +**Q: Hur säkrar jag indexmappen?** +A: Förvara indexet i en skyddad katalog, sätt korrekta filsystembehörigheter och överväg att kryptera indexet med bibliotekets säkerhetsfunktioner. + +--- + +**Senast uppdaterad:** 2026-02-08 +**Testad med:** GroupDocs.Search 25.4 for Java +**Författare:** GroupDocs \ No newline at end of file diff --git a/content/thai/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/thai/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..206cebc0 --- /dev/null +++ b/content/thai/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,221 @@ +--- +date: '2026-02-08' +description: เรียนรู้วิธีการไฮไลท์ผลการค้นหาใน Java และวิธีการทำดัชนีเอกสารด้วย Java + โดยใช้ GroupDocs.Search for Java พร้อมการทำดัชนีแบบซิงโครนัสและอะซิงโครนัส +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: ไฮไลท์ผลการค้นหา Java – การทำดัชนีแบบซิงโครนัสและอะซิงโครนัส +type: docs +url: /th/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# ไฮไลท์ผลการค้นหา Java – การทำดัชนีแบบซิงโครนัสและอะซิงโครนัส + +เพิ่มประสิทธิภาพแอปพลิเคชัน Java ของคุณด้วย **การไฮไลท์ผลการค้นหา Java** ด้วยไลบรารี GroupDocs.Search ที่ทรงพลัง ไม่ว่าคุณจะทำงานกับไฟล์ไม่กี่ไฟล์หรือคลังข้อมูลขนาดใหญ่ การเชี่ยวชาญทั้งการทำดัชนีแบบซิงโครนัสและอะซิงโครนัสจะช่วยให้คุณส่งมอบผลลัพธ์ที่เร็วและแม่นยำโดยไม่บล็อกเธรดของแอปพลิเคชัน + +## คำตอบอย่างรวดเร็ว +- **“highlight search results Java” หมายถึงอะไร?** หมายถึงการแสดงคำที่ตรงกันในผลการค้นหาด้วยสัญญาณภาพ (เช่น แท็ก HTML ``) เพื่อให้ผู้ใช้เห็นว่าคำค้นปรากฏที่ไหนในแต่ละเอกสาร +- **ควรใช้การทำดัชนีแบบซิงโครนัสเมื่อใด?** สำหรับชุดข้อมูลขนาดเล็กถึงกลางที่ต้องการให้เอกสารที่เพิ่มใหม่พร้อมใช้งานทันที +- **การทำดัชนีแบบอะซิงโครนัสเหมาะเมื่อใด?** เมื่อประมวลผลคอลเลกชันเอกสารขนาดใหญ่หรือทำงานบน UI thread ที่ต้องรักษาความตอบสนองของแอปพลิเคชัน +- **ต้องการไลเซนส์หรือไม่?** ทดลองใช้ฟรีสำหรับการพัฒนา; ไลเซนส์เต็มจะเปิดฟีเจอร์ขั้นสูงและลบข้อจำกัดการใช้งาน +- **รองรับเวอร์ชัน Java ใด?** Java 8 หรือใหม่กว่า + +## “highlight search results Java” คืออะไร? +การไฮไลท์ผลการค้นหาใน Java หมายถึงการนำผลการจับคู่ดิบที่ GroupDocs.Search คืนมาและห่อหุ้มคำที่ตรงกันด้วย HTML (หรือมาร์กอัปอื่น) เพื่อให้เด่นชัดเมื่อแสดงใน UI หรือหน้าเว็บ สิ่งนี้ช่วยปรับประสบการณ์ผู้ใช้โดยแสดงบริบทของแต่ละผลลัพธ์ทันที + +## ทำไมต้องใช้ GroupDocs.Search สำหรับ Java? +GroupDocs.Search ให้เครื่องมือค้นหาที่มีประสิทธิภาพสูงและไม่ขึ้นกับภาษา รองรับ: +- การทำดัชนีและการค้นหาแบบเรียลไทม์ +- การประมวลผลแบบอะซิงโครนัสสำหรับงานปริมาณมาก +- การไฮไลท์ผลลัพธ์ในตัว +- รองรับหลายภาษาและตัววิเคราะห์แบบกำหนดเอง + +ความสามารถเหล่านี้ทำให้เหมาะกับระบบจัดการเนื้อหา, แคตาล็อกอีคอมเมิร์ซ, และคลังเอกสารระดับองค์กร + +## ข้อกำหนดเบื้องต้น +ก่อนเริ่มทำงาน โปรดตรวจสอบว่าคุณมี: + +- **Java Development Kit** (JDK 8 หรือใหม่กว่า) ติดตั้งแล้ว +- IDE เช่น **IntelliJ IDEA** หรือ **Eclipse** +- โฟลเดอร์ที่มีเอกสารที่คุณต้องการทำดัชนี +- Maven สำหรับการจัดการ dependencies (หรือคุณสามารถดาวน์โหลด JAR ด้วยตนเอง) + +### ไลบรารีและ dependencies ที่จำเป็น +เพิ่ม GroupDocs.Search ไปยังโปรเจกต์ Maven ของคุณ: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +สำหรับการดาวน์โหลดโดยตรง ให้รับเวอร์ชันล่าสุดจาก [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### การตั้งค่าสภาพแวดล้อม +- ตรวจสอบว่า **JAVA_HOME** ของคุณชี้ไปยัง JDK ที่เข้ากันได้ +- สร้างโปรเจกต์ใน IDE ของคุณและเพิ่มการกำหนดค่า Maven ด้านบน +- เตรียมไดเรกทอรี (เช่น `documents/`) ที่มีไฟล์ข้อความ, PDF หรือ Word ตัวอย่าง + +## วิธีตั้งค่า GroupDocs.Search สำหรับ Java +1. **Install the Library** – ใช้สแนปช็อต Maven ด้านบนหรือดาวน์โหลด JAR จาก [GroupDocs](https://releases.groupdocs.com/search/java/) +2. **Obtain a License** – เริ่มต้นด้วยไลเซนส์ทดลอง แล้วอัปเกรดเมื่อย้ายไปสู่การผลิต +3. **Initialize the Index** – ตัวอย่างโค้ดต่อไปนี้แสดงวิธีสร้าง (หรือเปิด) โฟลเดอร์ดัชนี: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## วิธีไฮไลท์ผลการค้นหา Java – การทำดัชนีแบบซิงโครนัส +การทำดัชนีแบบซิงโครนัสจะประมวลผลเอกสารทันที ทำให้ไฟล์ที่เพิ่มใหม่พร้อมค้นหาได้โดยทันที + +### ขั้นตอน 1: สร้างดัชนีและแนบการจัดการข้อผิดพลาด +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### ขั้นตอน 2: เพิ่มเอกสารและทำการค้นหา +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### ขั้นตอน 3: ประมวลผลผลลัพธ์และ **ไฮไลท์ผลการค้นหา Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +`DocumentHighlighter` จะห่อหุ้มคำที่ตรงกันโดยอัตโนมัติด้วยแท็ก `` (หรือรูปแบบใด ๆ ที่คุณกำหนด) ทำให้คุณได้ **ผลลัพธ์การค้นหาที่ไฮไลท์** พร้อมแสดงผล + +## วิธีไฮไลท์ผลการค้นหา Java – การทำดัชนีแบบอะซิงโครนัส +เมื่อจัดการกับไฟล์หลายพันไฟล์ การบล็อกเธรดหลักเป็นสิ่งที่ไม่ต้องการ การทำดัชนีแบบอะซิงโครนัสทำให้เอนจินทำงานในพื้นหลัง + +### ขั้นตอน 1: ตั้งค่าดัชนีพร้อมกับ event listeners +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### ขั้นตอน 2: เปิดใช้งานโหมดอะซิงโครนัสและเริ่มทำดัชนี +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +ขณะที่ดัชนีกำลังสร้าง แอปพลิเคชันของคุณสามารถให้บริการคำขออื่นต่อไปได้ เมื่อเหตุการณ์ `StatusChanged` รายงาน `Ready` คุณสามารถทำการค้นหาอย่างปลอดภัยและรับ **ผลลัพธ์การค้นหาที่ไฮไลท์ Java** + +## วิธี **index documents java** – เคล็ดลับปฏิบัติ +- **Batch size**: สำหรับคอลเลกชันขนาดใหญ่ ให้แบ่งโฟลเดอร์เป็นชุดย่อยเพื่อหลีกเลี่ยงการกระตุ้นหน่วยความจำสูงขึ้น +- **File filters**: ใช้ `IndexingOptions.setFileExtensions` เพื่อรวมเฉพาะรูปแบบที่ต้องการ (เช่น `.pdf`, `.docx`) +- **Re‑indexing**: เมื่อเอกสารมีการเปลี่ยนแปลง ให้เรียก `index.update(documentPath)` แทนการสร้างดัชนีใหม่ทั้งหมด + +## พิจารณาด้านประสิทธิภาพ +- **Memory**: ตรวจสอบการใช้ heap; เพิ่ม `-Xmx` หากประมวลผลไฟล์ขนาดใหญ่หลายไฟล์ +- **CPU**: การทำดัชนีแบบอะซิงโครนัสกระจายภาระงาน แต่ยังคงใช้ CPU — ควรตรวจสอบด้วย JVisualVM +- **Result Highlighting**: การไฮไลท์เพิ่มภาระการประมวลผลเล็กน้อย; ควรแคช HTML ที่สร้างขึ้นหากต้องแสดงผลลัพธ์ซ้ำหลายครั้ง + +## คำถามที่พบบ่อย + +**Q: สามารถผสานการทำดัชนีแบบซิงโครนัสและอะซิงโครนัสในแอปพลิเคชันเดียวกันได้หรือไม่?** +A: ได้. ใช้การทำดัชนีแบบซิงโครนัสสำหรับชุดข้อมูลขนาดเล็กที่อัปเดตบ่อย และใช้การทำดัชนีแบบอะซิงโครนัสสำหรับการนำเข้าจำนวนมากหรืองานพื้นหลัง + +**Q: จะปรับแต่งสไตล์การไฮไลท์อย่างไร?** +A: ให้สร้างการนำเข้า `DocumentHighlighter` แบบกำหนดเองที่เขียนแท็ก HTML, CSS หรือ XML ที่ต้องการล้อมรอบคำที่ตรงกัน + +**Q: GroupDocs.Search รองรับประเภทไฟล์ใดบ้างโดยตรง?** +A: Text, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML, และอื่น ๆ อีกมากมายผ่านตัวแปลงในตัว + +**Q: สามารถค้นหาในหลายภาษาพร้อมกันได้หรือไม่?** +A: แน่นอน. GroupDocs.Search มีตัววิเคราะห์หลายภาษา; เพียงกำหนด `Analyzer` ที่เหมาะสมเมื่อสร้างดัชนี + +**Q: จะรักษาความปลอดภัยของโฟลเดอร์ดัชนีอย่างไร?** +A: เก็บดัชนีในไดเรกทอรีที่ได้รับการปกป้อง ตั้งค่าการอนุญาตไฟล์ระบบให้เหมาะสม และพิจารณาเข้ารหัสดัชนีด้วยฟีเจอร์ความปลอดภัยของไลบรารี + +--- + +**Last Updated:** 2026-02-08 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs \ No newline at end of file diff --git a/content/turkish/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/turkish/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..2a3cb149 --- /dev/null +++ b/content/turkish/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,222 @@ +--- +date: '2026-02-08' +description: Java'da arama sonuçlarını nasıl vurgulayacağınızı ve GroupDocs.Search + for Java kullanarak senkron ve asenkron indeksleme ile belgeleri nasıl indeksleyeceğinizi + öğrenin. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Vurgulama Arama Sonuçları Java – Senkron ve Asenkron Dizinleme +type: docs +url: /tr/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Java’da Arama Sonuçlarını Vurgulama – Senkron ve Async İndeksleme + +Boost your Java applications by **highlighting search results Java** with the powerful GroupDocs.Search library. Whether you’re dealing with a few files or a massive repository, mastering both synchronous and asynchronous indexing lets you deliver fast, accurate results without blocking your application threads. + +## Hızlı Yanıtlar +- **“highlight search results Java” ne anlama geliyor?** Arama sonuçlarında eşleşen terimleri görsel ipuçları (ör. HTML `` etiketleri) ile render etmeyi ifade eder, böylece kullanıcılar sorgunun her belgede nerede göründüğünü görebilir. +- **Senkron indekslemeyi ne zaman kullanmalıyım?** Yeni eklenen belgelerin anında kullanılabilir olması gereken küçük ve orta ölçekli veri setleri için. +- **Asenkron indeksleme ne zaman tercih edilir?** Büyük belge koleksiyonlarını işlerken veya uygulamanın yanıt vermeye devam etmesi gereken bir UI iş parçacığında çalışırken. +- **Bir lisansa ihtiyacım var mı?** Geliştirme için ücretsiz deneme yeterlidir; tam lisans gelişmiş özellikleri açar ve kullanım limitlerini kaldırır. +- **Hangi Java sürümü destekleniyor?** Java 8 veya üzeri. + +## “highlight search results Java” nedir? +Java’da arama sonuçlarını vurgulamak, GroupDocs.Search tarafından döndürülen ham eşleşmeleri alıp eşleşen terimleri HTML (veya başka bir işaretleme dili) içinde sararak bir UI veya web sayfasında görüntülendiğinde öne çıkmasını sağlamaktır. Bu, her bir eşleşmenin bağlamını anında göstererek kullanıcı deneyimini iyileştirir. + +## Neden Java için GroupDocs.Search kullanmalı? +GroupDocs.Search, yüksek performanslı, dil bağımsız bir motor sunar ve şunları destekler: +- Gerçek zamanlı indeksleme ve arama +- Büyük iş yükleri için asenkron işleme +- Yerleşik sonuç vurgulama +- Çok dilli ve özel analizör desteği + +Bu yetenekler, içerik yönetim sistemleri, e‑ticaret katalogları ve kurumsal belge depoları için ideal kılar. + +## Önkoşullar +Başlamadan önce aşağıdakilere sahip olduğunuzdan emin olun: + +- **Java Development Kit** (JDK 8 veya daha yeni) yüklü. +- **IntelliJ IDEA** veya **Eclipse** gibi bir IDE. +- İndekslemek istediğiniz belgeleri içeren bir klasör. +- Bağımlılık yönetimi için Maven (veya JAR dosyasını manuel olarak indirebilirsiniz). + +### Gerekli Kütüphaneler ve Bağımlılıklar +Maven projenize GroupDocs.Search ekleyin: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Doğrudan indirme için, en son sürümü [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) adresinden alın. + +### Ortam Kurulumu +- **JAVA_HOME**'unuzun uyumlu bir JDK'ye işaret ettiğini doğrulayın. +- IDE'nizde bir proje oluşturun ve yukarıdaki Maven yapılandırmasını ekleyin. +- Örnek metin, PDF veya Word dosyaları içeren bir dizin (ör. `documents/`) hazırlayın. + +## GroupDocs.Search for Java Nasıl Kurulur +1. **Kütüphaneyi Kurun** – Yukarıdaki Maven snippet'ini kullanın veya JAR dosyasını [GroupDocs](https://releases.groupdocs.com/search/java/) adresinden indirin. +2. **Lisans Alın** – Öncelikle bir deneme lisansı alın, ardından üretime geçtiğinizde yükseltin. +3. **İndeksi Başlatın** – Aşağıdaki snippet, bir indeks klasörü oluşturmayı (veya açmayı) gösterir: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## Java’da arama sonuçlarını vurgulama – Senkron İndeksleme +Senkron indeksleme, belgeleri anında işler ve yeni eklenen dosyaların hemen aranabilir olmasını sağlar. + +### Adım 1: İndeksi oluşturun ve hata yönetimini ekleyin +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Adım 2: Belgeleri ekleyin ve bir arama çalıştırın +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Adım 3: Sonuçları işleyin ve **highlight search results Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +`DocumentHighlighter`, eşleşen terimleri otomatik olarak `` etiketleri (veya yapılandırdığınız herhangi bir format) ile sarar ve size **highlighted search results** (vurgulanmış arama sonuçları) gösterime hazır hâle getirir. + +## Java’da arama sonuçlarını vurgulama – Asenkron İndeksleme +Binlerce dosyayla çalışırken ana iş parçacığını engellemek istenmez. Asenkron indeksleme, motorun arka planda çalışmasını sağlar. + +### Adım 1: Olay dinleyicileriyle indeksi kurun +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Adım 2: Asenkron modu etkinleştirin ve indekslemeyi başlatın +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +İndeks oluşturulurken uygulamanız diğer istekleri hizmet vermeye devam edebilir. `StatusChanged` olayı `Ready` (Hazır) rapor ettiğinde, güvenle arama yapabilir ve **highlighted search results Java** elde edebilirsiniz. + +## **index documents java** Nasıl Yapılır – Pratik İpuçları +- **Batch size**: Büyük koleksiyonlar için klasörü daha küçük partilere bölerek bellek dalgalanmalarını önleyin. +- **File filters**: `IndexingOptions.setFileExtensions` kullanarak yalnızca ihtiyacınız olan formatları (ör. `.pdf`, `.docx`) dahil edin. +- **Re‑indexing**: Belgeler değiştiğinde tüm indeksi yeniden oluşturmak yerine `index.update(documentPath)` çağırın. + +## Performans Düşünceleri +- **Memory**: Yığın kullanımını izleyin; çok sayıda büyük dosya işliyorsanız `-Xmx` değerini artırın. +- **CPU**: Asenkron indeksleme iş yükünü dağıtır, ancak hâlâ CPU tüketir—JVisualVM ile izleyin. +- **Result Highlighting**: Vurgulama küçük bir işlem ek yükü ekler; sonuçları tekrar tekrar göstermeniz gerekiyorsa oluşturulan HTML'i önbelleğe alın. + +## Sıkça Sorulan Sorular + +**S: Senkron ve asenkron indekslemeyi aynı uygulamada birleştirebilir miyim?** +C: Evet. Küçük, sık güncellenen setler için senkron indeksleme, toplu ithalatlar veya arka plan görevleri için asenkron indeksleme kullanın. + +**S: Vurgulama stilini nasıl özelleştirebilirim?** +C: Eşleşen terimler etrafına istediğiniz HTML, CSS veya XML etiketlerini yazan özel bir `DocumentHighlighter` uygulaması sağlayın. + +**S: GroupDocs.Search varsayılan olarak hangi dosya türlerini destekliyor?** +C: Metin, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML ve dahili ayrıştırıcıları sayesinde daha birçok format. + +**S: Aynı anda birden fazla dilde arama yapmak mümkün mü?** +C: Kesinlikle. GroupDocs.Search çok‑dilli analizörler içerir; indeks oluştururken uygun `Analyzer`'ı yapılandırmanız yeterlidir. + +**S: İndeks klasörünü nasıl güvence altına alabilirim?** +C: İndeksi korumalı bir dizinde saklayın, uygun dosya sistemi izinlerini ayarlayın ve kütüphanenin güvenlik özellikleriyle indeksi şifrelemeyi düşünün. + +--- + +**Son Güncelleme:** 2026-02-08 +**Test Edilen Sürüm:** GroupDocs.Search 25.4 for Java +**Yazar:** GroupDocs \ No newline at end of file diff --git a/content/vietnamese/java/searching/master-groupdocs-search-java-document-indexing/_index.md b/content/vietnamese/java/searching/master-groupdocs-search-java-document-indexing/_index.md new file mode 100644 index 00000000..95809709 --- /dev/null +++ b/content/vietnamese/java/searching/master-groupdocs-search-java-document-indexing/_index.md @@ -0,0 +1,222 @@ +--- +date: '2026-02-08' +description: Tìm hiểu cách làm nổi bật kết quả tìm kiếm Java và cách lập chỉ mục tài + liệu Java bằng GroupDocs.Search for Java với việc lập chỉ mục đồng bộ và bất đồng + bộ. +keywords: +- document search +- synchronous indexing +- asynchronous indexing +title: Làm nổi bật kết quả tìm kiếm Java – Đánh chỉ mục đồng bộ và bất đồng bộ +type: docs +url: /vi/java/searching/master-groupdocs-search-java-document-indexing/ +weight: 1 +--- + +# Làm nổi bật Kết quả Tìm kiếm Java – Đánh chỉ mục Đồng bộ & Bất đồng bộ + +Boost your Java applications by **highlighting search results Java** with the powerful GroupDocs.Search library. Whether you’re dealing with a few files or a massive repository, mastering both synchronous and asynchronous indexing lets you deliver fast, accurate results without blocking your application threads. + +## Câu trả lời nhanh +- **“highlight search results Java” có nghĩa là gì?** Nó đề cập đến việc hiển thị các thuật ngữ khớp trong kết quả tìm kiếm bằng các dấu hiệu trực quan (ví dụ, thẻ HTML ``) để người dùng có thể thấy vị trí truy vấn xuất hiện trong mỗi tài liệu. +- **Khi nào nên sử dụng đánh chỉ mục đồng bộ?** Đối với các bộ dữ liệu nhỏ đến trung bình, nơi cần tài liệu mới thêm có sẵn ngay lập tức. +- **Khi nào nên ưu tiên đánh chỉ mục bất đồng bộ?** Khi xử lý các bộ sưu tập tài liệu lớn hoặc chạy trên luồng UI mà bạn phải giữ cho ứng dụng phản hồi nhanh. +- **Tôi có cần giấy phép không?** Bản dùng thử miễn phí đủ cho việc phát triển; giấy phép đầy đủ mở khóa các tính năng nâng cao và loại bỏ giới hạn sử dụng. +- **Phiên bản Java nào được hỗ trợ?** Java 8 hoặc mới hơn. + +## “highlight search results Java” là gì? +Làm nổi bật kết quả tìm kiếm trong Java có nghĩa là lấy các kết quả khớp thô do GroupDocs.Search trả về và bao bọc các thuật ngữ khớp trong HTML (hoặc một markup khác) để chúng nổi bật khi hiển thị trong UI hoặc trang web. Điều này cải thiện trải nghiệm người dùng bằng cách ngay lập tức hiển thị ngữ cảnh của mỗi kết quả. + +## Tại sao nên sử dụng GroupDocs.Search cho Java? +GroupDocs.Search cung cấp một engine hiệu suất cao, ngôn ngữ‑không‑phụ thuộc, hỗ trợ: +- Đánh chỉ mục và tìm kiếm thời gian thực +- Xử lý bất đồng bộ cho khối lượng công việc lớn +- Tích hợp sẵn tính năng làm nổi bật kết quả +- Hỗ trợ đa ngôn ngữ và bộ phân tích tùy chỉnh + +Những khả năng này làm cho nó trở thành lựa chọn lý tưởng cho hệ thống quản lý nội dung, danh mục thương mại điện tử và kho tài liệu doanh nghiệp. + +## Yêu cầu trước +Trước khi bắt đầu, hãy chắc chắn rằng bạn đã có: + +- **Java Development Kit** (JDK 8 hoặc mới hơn) đã được cài đặt. +- Một IDE như **IntelliJ IDEA** hoặc **Eclipse**. +- Một thư mục chứa các tài liệu bạn muốn đánh chỉ mục. +- Maven để quản lý phụ thuộc (hoặc bạn có thể tải JAR thủ công). + +### Thư viện và Phụ thuộc Yêu cầu +Thêm GroupDocs.Search vào dự án Maven của bạn: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Đối với tải xuống trực tiếp, lấy phiên bản mới nhất từ [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Cài đặt Môi trường +- Xác minh **JAVA_HOME** của bạn trỏ tới JDK tương thích. +- Tạo một dự án trong IDE và thêm cấu hình Maven ở trên. +- Chuẩn bị một thư mục (ví dụ, `documents/`) chứa các tệp văn bản, PDF hoặc Word mẫu. + +## Cách thiết lập GroupDocs.Search cho Java +1. **Cài đặt Thư viện** – Sử dụng đoạn mã Maven ở trên hoặc tải JAR từ [GroupDocs](https://releases.groupdocs.com/search/java/). +2. **Nhận Giấy phép** – Bắt đầu với giấy phép dùng thử, sau đó nâng cấp khi bạn chuyển sang môi trường sản xuất. +3. **Khởi tạo Chỉ mục** – Đoạn mã dưới đây cho thấy cách tạo (hoặc mở) một thư mục chỉ mục: + +```java +import com.groupdocs.search.Index; + +// Create an index in the specified folder +Index index = new Index("path/to/index/folder"); +``` + +## Cách làm nổi bật kết quả tìm kiếm Java – Đánh chỉ mục Đồng bộ +Đánh chỉ mục đồng bộ xử lý tài liệu ngay lập tức, khiến các tệp mới thêm có thể tìm kiếm ngay lập tức. + +### Bước 1: Tạo chỉ mục và gắn xử lý lỗi +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; +import java.nio.file.Paths; + +public class SynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/SynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); +``` + +### Bước 2: Thêm tài liệu và thực hiện tìm kiếm +```java + // Add documents + index.add(documentsFolder); + + // Perform a search + String query = "tincidunt"; + SearchResult result = index.search(query); +``` + +### Bước 3: Xử lý kết quả và **làm nổi bật kết quả tìm kiếm Java** +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println(": Document: " + document.getDocumentInfo().getFilePath()); + System.out.println(": Occurrences: " + document.getOccurrenceCount()); + } + + // Highlight results + if (result.getDocumentCount() > 0) { + FoundDocument document = result.getFoundDocument(0); + String path = YOUR_OUTPUT_DIRECTORY + "/Highlighted.html"; + OutputAdapter outputAdapter = new FileOutputAdapter(OutputFormat.Html, path); + DocumentHighlighter highlighter = new DocumentHighlighter(outputAdapter); + index.highlight(document, highlighter); + } + } +} +``` + +`DocumentHighlighter` tự động bao bọc các thuật ngữ khớp bằng thẻ `` (hoặc bất kỳ định dạng nào bạn cấu hình), cung cấp **kết quả tìm kiếm đã được làm nổi bật** sẵn sàng để hiển thị. + +## Cách làm nổi bật kết quả tìm kiếm Java – Đánh chỉ mục Bất đồng bộ +Khi xử lý hàng ngàn tệp, việc chặn luồng chính là không mong muốn. Đánh chỉ mục bất đồng bộ cho phép engine làm việc ở nền. + +### Bước 1: Thiết lập chỉ mục với các trình nghe sự kiện +```java +import com.groupdocs.search.*; +import com.groupdocs.search.events.*; + +public class AsynchronousIndexingFeature { + public static void main(String[] args) { + String indexFolder = "YOUR_DOCUMENT_DIRECTORY/AsynchronousIndexing"; + String documentsFolder = YOUR_DOCUMENT_DIRECTORY; // Replace with actual directory path + + Index index = new Index(indexFolder); + + // Handle errors and status changes + index.getEvents().ErrorOccurred.add(new EventHandler() { + @Override + public void invoke(Object sender, IndexErrorEventArgs args) { + System.out.println(args.getMessage()); + } + }); + + index.getEvents().StatusChanged.add(new EventHandler() { + @Override + public void invoke(Object sender, BaseIndexEventArgs args) { + if (args.getStatus() != IndexStatus.Ready || args.getStatus() == IndexStatus.Failed) { + System.out.println("Indexing completed."); + } + } + }); +``` + +### Bước 2: Kích hoạt chế độ bất đồng bộ và bắt đầu đánh chỉ mục +```java + // Set up async indexing options + IndexingOptions options = new IndexingOptions(); + options.setAsync(true); + + // Add documents asynchronously + index.add(documentsFolder, options); + } +} +``` + +Trong khi chỉ mục đang được xây dựng, ứng dụng của bạn vẫn có thể tiếp tục phục vụ các yêu cầu khác. Khi sự kiện `StatusChanged` báo `Ready`, bạn có thể an toàn thực hiện tìm kiếm và nhận **kết quả tìm kiếm đã được làm nổi bật Java**. + +## Cách **đánh chỉ mục tài liệu java** – Mẹo Thực tế +- **Kích thước lô**: Đối với các bộ sưu tập lớn, chia thư mục thành các lô nhỏ hơn để tránh tăng đột biến bộ nhớ. +- **Bộ lọc tệp**: Sử dụng `IndexingOptions.setFileExtensions` để chỉ bao gồm các định dạng cần thiết (ví dụ, `.pdf`, `.docx`). +- **Đánh chỉ mục lại**: Khi tài liệu thay đổi, gọi `index.update(documentPath)` thay vì xây dựng lại toàn bộ chỉ mục. + +## Các lưu ý về Hiệu năng +- **Bộ nhớ**: Theo dõi việc sử dụng heap; tăng `-Xmx` nếu bạn xử lý nhiều tệp lớn. +- **CPU**: Đánh chỉ mục bất đồng bộ phân tán tải công việc, nhưng vẫn tiêu thụ CPU—giám sát bằng JVisualVM. +- **Làm nổi bật Kết quả**: Việc làm nổi bật thêm một chút chi phí xử lý; lưu cache HTML đã tạo nếu bạn cần hiển thị kết quả nhiều lần. + +## Câu hỏi thường gặp + +**Q: Tôi có thể kết hợp đánh chỉ mục đồng bộ và bất đồng bộ trong cùng một ứng dụng không?** +A: Có. Sử dụng đánh chỉ mục đồng bộ cho các tập dữ liệu nhỏ, thường xuyên cập nhật và đánh chỉ mục bất đồng bộ cho việc nhập khẩu hàng loạt hoặc các công việc nền. + +**Q: Làm thế nào để tùy chỉnh kiểu làm nổi bật?** +A: Cung cấp một triển khai `DocumentHighlighter` tùy chỉnh để ghi các thẻ HTML, CSS hoặc XML mong muốn quanh các thuật ngữ khớp. + +**Q: GroupDocs.Search hỗ trợ những loại tệp nào ngay từ đầu?** +A: Văn bản, PDF, DOC/DOCX, XLS/XLSX, PPT/PPTX, HTML và nhiều loại khác thông qua các bộ phân tích tích hợp. + +**Q: Có thể tìm kiếm đồng thời bằng nhiều ngôn ngữ không?** +A: Chắc chắn. GroupDocs.Search bao gồm các bộ phân tích đa ngôn ngữ; chỉ cần cấu hình `Analyzer` phù hợp khi tạo chỉ mục. + +**Q: Làm sao để bảo mật thư mục chỉ mục?** +A: Lưu chỉ mục trong một thư mục được bảo vệ, thiết lập quyền truy cập hệ thống tệp phù hợp và cân nhắc mã hoá chỉ mục bằng các tính năng bảo mật của thư viện. + +--- + +**Cập nhật lần cuối:** 2026-02-08 +**Kiểm tra với:** GroupDocs.Search 25.4 for Java +**Tác giả:** GroupDocs \ No newline at end of file