diff --git a/content/arabic/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md b/content/arabic/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md new file mode 100644 index 00000000..21ef2d81 --- /dev/null +++ b/content/arabic/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md @@ -0,0 +1,227 @@ +--- +date: '2026-01-21' +description: تعلم كيفية إضافة تبعية GroupDocs Maven، وتكوين ومزامنة شبكة البحث في + Java، وإضافة الأدلة إلى الفهرس باستخدام GroupDocs.Search. +keywords: +- Java Search Network Configuration +- GroupDocs.Search for Java +- Document Indexing and Retrieval +title: اعتماد Maven من GroupDocs – مزامنة شبكة البحث في Java +type: docs +url: /ar/java/search-network/java-groupdocs-search-configuration-sync-guide/ +weight: 1 +--- + +# تبعية GroupDocs Maven: تكوين ومزامنة شبكات البحث Java + +في هذا الدليل الشامل ستكتشف **كيفية إضافة تبعية GroupDocs Maven** إلى مشروعك ثم تكوين شبكة بحث Java قوية باستخدام GroupDocs.Search. سواء كنت تتعامل مع المذكرات القانونية أو التقارير المالية أو الأوراق الأكاديمية، فإن الخطوات أدناه ستساعدك على فهرسة، بحث، والحفاظ على تزامن القطع (shards) بكفاءة. + +## المقدمة + +إدارة والبحث في مجموعات ضخمة من المستندات يمثل تحديًا يوميًا للعديد من المؤسسات. من خلال دمج **تبعية GroupDocs Maven**، ستحصل على محرك فهرسة قوي يمكنه التوسع عبر عدة عقد. يوضح هذا البرنامج التعليمي كيفية إعداد التبعية، نشر عقد الشبكة، إضافة أدلة للفهرسة، ومزامنة القطع لتحقيق الأداء المثالي. + +### إجابات سريعة +- **ما هي تبعية GroupDocs Maven؟** هي قطعة Maven تجلب مكتبة GroupDocs.Search إلى مشروع Java الخاص بك. +- **لماذا نستخدم شبكة بحث؟** لأنها توزع حمل الفهرسة والاستعلام عبر عدة عقد، مما يحسن السرعة والموثوقية. +- **كيف أضيف أدلة للفهرسة؟** استخدم `IndexingDocuments.addDirectories` على العقدة الرئيسية. +- **كيف أزامن القطع؟** استدعِ `SynchronizeOptions` على كل `Indexer` في العقدة. +- **هل أحتاج إلى ترخيص؟** نعم، يلزم وجود ترخيص تجريبي أو تجاري للاستخدام في الإنتاج. + +## ما هي تبعية GroupDocs Maven؟ + +تبعية GroupDocs Maven (`com.groupdocsتمادات. + +##بعية إلى ملف `pom.xml` الخاص بك: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +> **نصيحة محترف:** حافظ على تحديث رقم الإصدار بالتحقق من صفحة الإصدارات الرسمية. + +يمكنك أيضًا تنزيل ملف JAR مباشرةً من الموقع الرسمي: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +## المتطلبات المسبقة + +- **JDK** (الإصدار 11 أو أحدث) مثبت. +- بيئة تطوير متكاملة مثل IntelliJ IDEA أو Eclipse. +- معرفة أساسية بـ Java، إلمام بـ Maven، وفهم لمفاهيم عقد الشبكة. +- ترخيص صالح لـ GroupDocs.Search (تجريبي مجاني أو تجاري). + +## التهيئة الأساسية والإعداد + +ابدأ بإنشاء دليل الفهرس: + +```java +import com.groupdocs.search.SearchIndex; +import com.groupdocs.search.options.IndexingOptions; + +// Create an index in the specified directory +SearchIndex index = new SearchIndex("YOUR_INDEX_DIRECTORY"); +``` + +هذه الخطوة البسيطة تُعد البيئة للتهيئة اللاحقة للشبكة. + +## دليل التنفيذ + +### الميزة 1: تكوين شبكة البحث + +#### نظرة عامة + +تكوين شبكة البحث يحدد مسارات الملفات والمنافذ التي ستستخدمها العقد للتواصل. + +##### إعداد المسارات والمنافذ +```java +import com.groupdocs.search.options.*; +import com.groupdocs.search.scaling.configuring.ConfiguringSearchNetwork; + +// Set custom paths for input/output directories +String basePath = "YOUR_DOCUMENT_DIRECTORY/AdvancedUsage/Scaling/SynchronizingShards/"; +int basePort = 49144; // Adjust if there's a port conflict + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` +كائن `configuration` الآن يحتوي على جميع الإعدادات اللازمة لشبكة البحث الخاصة بك. + +### الميزة 2: نشر عقد شبكة البحث + +#### نظرة عامة + +انشر العقد لتوزيع عبء العمل عبر شبكتك. العقدة الرئيسية تدير العمليات والأحداث. + +##### شفرة النشر +```java +import com.groupdocs.search.scaling.*; +import com.groupdocs.search.options.Configuration; + +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +// Retrieve the master node for further operations +SearchNetworkNode masterNode = nodes[0]; +``` + +### الميزة 3: الاشتراك في أحداث عقد شبكة البحث + +#### نظرة عامة + +الاستماع للأحداث يتيح التعامل الديناميكي مع التغييرات أو التحديثات في شبكتك. + +##### تنفيذ الاشتراك +```java +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.scaling.SearchNetworkNodeEvents; + +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### الميزة 4: إضافة أدلة للفهرسة + +#### نظرة عامة + +إضافة الأدلة هي الخطوة الأساسية التي تجعل مستنداتك قابلة للبحث. + +##### إضافة المستندات +```java +import com.groupdocs.search.indexing.IndexingDocuments; +import com.groupdocs.search.scaling.SearchNetworkNode; + +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +``` + +### الميزة 5: مزامنة القطع في عقدة شبكة البحث + +#### نظرة عامة + +المزامنة تضمن اتساق البيانات عبر جميع القطع. + +##### شفرة المزامنة +```java +import com.groupdocs.search.indexing.Indexer; +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.options.SynchronizeOptions; + +SearchNetworkNode node = null; // Assume 'node' is initialized as a SearchNetworkNode + +def synchronizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + SynchronizeOptions options = new SynchronizeOptions(); + indexer.synchronize(options); +} +``` + +### الميزة 6: إغلاق عقد شبكة البحث + +#### نظرة عامة + +إغلاق العقد بشكل صحيح يحرر الموارد ويمنع تسرب الذاكرة. + +##### إغلاق العقدة +```java +import com.groupdocs.search.scaling.SearchNetworkNode; + +for (SearchNetworkNode node : nodes) { + node.close(); +} +``` + +## التطبيقات العملية + +1. **إدارة المستندات القانونية** – استرجاع ملفات القضايا والسوابق بسرعة. +2. **حفظ السجلات المالية** – الوصول إلى البيانات المالية وسجلات التدقيق في ثوانٍ. +3. **البحث الأكاديمي** – البحث عبر آلاف الأوراق للعثور على الاستشهادات ذات الصلة. + +## اعتبارات الأداء + +- **تحسين الاستعلامات** – اكتب استعلامات مختصرة لتقليل زمن الاستجابة. +- **إدارة الذاكرة** – راقب استهلاك heap في JVM؛ فكر في ضبط GC للفهارس الكبيرة. +- **استراتيجية التوسع** – أضف عقدًا بما يتناسب مع حجم البيانات وحمل الاستعلامات. + +## المشكلات الشائعة والحلول + +| المشكلة | السبب | الحل | +|-------|-------|----------| +| فشل العقد في الاتصال | تعارض في المنفذ | غيّر `basePort` إلى قيمة غير مستخدمة | +| الفهرس لا يتم تحديثه | عدم وجود اشتراك في الأحداث | تأكد من استدعاء `SearchNetworkNodeEvents.subscribe(masterNode)` | +| ارتفاع زمن الاستجابة | عدد غير كافٍ من القطع | زد عدد العقد ووازن توزيع المستندات | + +## الأسئلة المتكررة + +**س: ما الفائدة الأساسية من استخدام GroupDocs.Search؟** +ج: يوفر قدرات بحث سريعة وقابلة للتوسع عبر مجموعات مستندات كبيرة مع إعدادات قليلة. + +**س: هل يمكنني تخصيص إعدادات العقد في شبكة البحث؟** +ج: نعم، يمكنك تعيين مسارات مخصصة، منافذ، وخيارات أخرى عبر كائن `Configuration`. + +**س: كيف أضيف أدلة للفهرسة بعد تشغيل الشبكة؟** +ج: استدعِ `IndexingDocuments.addDirectories(masterNode, "path")` كلما احتجت إلى فهرسة مجلدات جديدة. + +**س: كيف أزامن القطع عندما تنضم عقدة جديدة إلى الشبكة؟** +ج: استخدم طريقة `synchronizeShards` الموضحة أعلاه على العقدة المضافة حديثًا. + +**س: هل أحتاج إلى ترخيص للتطوير؟** +ج: الترخيص التجريبي مجاني للاختبار؛ الترخيص التجاري مطلوب للإنتاج. + +## الخاتمة + +باتباع هذا الدليل أصبحت الآن تعرف **كيفية إضافة تبعية GroupDocs Maven**، تكوين شبكة بحث متعددة العقد، فهرسة الأدلة، والحفاظ على تزامن القطع. تشكل هذه الخطوات الأساس لحل بحث مستندات عالي الأداء يمكنه النمو مع احتياجات مؤسستك. + +--- + +**آخر تحديث:** 2026-01-21 +**تم الاختبار مع:** GroupDocs.Search 25.4 +**المؤلف:** GroupDocs + +--- \ No newline at end of file diff --git a/content/arabic/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/arabic/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..ea1922b5 --- /dev/null +++ b/content/arabic/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,212 @@ +--- +date: '2026-01-21' +description: تعلم كيفية تحسين القطع باستخدام GroupDocs.Search للغة Java وكيفية تكوين + شبكة البحث، وإجراء بحث نصي، ومعالجة تعارضات المنافذ. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'كيفية تحسين التجزئات في GroupDocs.Search للغة Java: دليل شامل' +type: docs +url: /ar/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# كيفية تحسين الشظايا في GroupDocs.Search للـ Java: دليل شامل + +البحث الفعال في المستندات أمر أساسي للمطورين والشركات التي تدير قواعد بيانات ضخمة أو تسعى لتبسيط عمليات استرجاع المستندات الداخلية. إذا كنت تتساءل **عن كيفية تحسين الشظايا**، سيوضح لك هذا الدليل الخطوات اللازمة لتحسين الأداء، وتكوين شبكة البحث الخاصة بك، ومعالجة التحديات الشائعة مثل تعارض المنافذ. **GroupDocs.Search Java** يوفر تكوينًا سلسًا وتحسينًا لشبكة البحث، مما يعزز كلًا من الأداء وتجربة المستخدم. + +## إجابات سريعة +- **ما هو تحسين الشظايا؟** يعيد تنظيم بيانات الفهرس لتسريع الاستعلامات وتقليل استهلاك التخزين. +- **كيف يتم تكوين شبكة البحث؟** حدد دليلًا أساسيًا ومنفذًا، ثم انشر العقد باستخدام الـ API المقدم. +- **كيف يتم تنفيذ بحث نصي؟** استخدم `TextSearchInNetwork.searchAll` مع سلسلة الاستعلام الخاصة بك. +- **كيف يتم فهرسة المستندات في Java؟** أضف دلائل المستندات إلى العقدة الرئيسية باستخدام `IndexingDocuments.addDirectories`. +- **كيف يتم التعامل مع تعارض المنافذ؟** غيّر قيمة المتغير `basePort` إلى منفذ غير مستخدم على جهازك. + +## كيفية تكوين شبكة البحث +قبل الغوص في الفهرسة والبحث، تحتاج إلى أساس شبكة قوي. يشرح هذا القسم الخطوات اللازمة لإعداد الشبكة، اختيار المنفذ، وتجنب مشاكل تعارض المنافذ الشائعة. + +## كيفية فهرسة المستندات في Java +بمجرد تشغيل الشبكة، الخطوة التالية هي تغذيتها بالمحتوى. سنوضح لك كيفية إضافة مجلدات مستندات متعددة حتى يتمكن المحرك من بناء فهرس قابل للبحث. + +## كيفية تنفيذ بحث نصي +بعد الفهرسة، ستحتاج إلى استرجاع المعلومات بسرعة. يوضح هذا الجزء أبسط طريقة لتشغيل استعلام نصي عبر جميع العقد. + +## كيفية التعامل مع تعارض المنافذ +إذا كان المنفذ الافتراضي (`49132`) مستخدمًا بالفعل، ما عليك سوى تغيير قيمة `basePort` إلى منفذ فارغ وإعادة تشغيل التكوين. هذا يمنع أخطاء بدء التشغيل ويحافظ على استقرار الشبكة. + +## المتطلبات المسبقة +قبل أن نبدأ، تأكد من توفر المتطلبات التالية: + +### المكتبات المطلوبة والإصدارات والاعتمادات +لتنفيذ هذا الحل، أدرج مكتبة GroupDocs.Search باستخدام Maven بإضافة التكوين التالي إلى ملف `pom.xml` الخاص بك: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` +بدلاً من ذلك، حمّل أحدث نسخة من [إصدارات GroupDocs.Search للـ Java](https://releases.groupdocs.com/search/java/). + +### متطلبات إعداد البيئة +- تأكد من أن بيئة التطوير تدعم Java (JDK 8 أو أحدث). +- توفر تكوين شبكة يسمح باستخدام المنافذ. + +### المتطلبات المعرفية +فهم أساسي لبرمجة Java، بما في ذلك مبادئ البرمجة الكائنية ومعالجة الاستثناءات، سيكون مفيدًا لهذا الدرس. + +## إعداد GroupDocs.Search للـ Java +لبدء استخدام GroupDocs.Search في مشروعك، اتبع الخطوات التالية: + +1. **إضافة الاعتمادية**: كما هو موضح أعلاه، أضف الاعتمادية المطلوبة إلى مشروعك عبر Maven أو حمّلها مباشرة من صفحة الإصدارات. +2. **الحصول على الترخيص**: + - للحصول على نسخة تجريبية مجانية، استخدم المكتبة دون قيود على الميزات مع بعض القيود على الاستخدام. + - احصل على ترخيص مؤقت للوصول الكامل إلى الميزات أثناء التقييم بزيارة [ترخيص GroupDocs المؤقت](https://purchase.groupdocs.com/temporary-license/). + - اشترِ ترخيصًا كاملًا إذا قررت دمج GroupDocs.Search في بيئة الإنتاج الخاصة بك. +3. **التهيئة الأساسية والإعداد**: + قم بتهيئة الإعدادات باستخدام فئة `Configuration`، مع تحديد المسار الأساسي للمستندات وتحديد رقم المنفذ: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## دليل التنفيذ +الآن دعنا نستكشف تنفيذ الميزات الرئيسية باستخدام GroupDocs.Search للـ Java. + +### الميزة: تكوين شبكة البحث +**نظرة عامة**: إعداد شبكة البحث يتضمن تعريف دليل المستندات وتكوينه بمنفذ محدد للتواصل بين العقد. + +#### الخطوة 1: تعريف دلائل المستندات والمنفذ +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### الخطوة 2: تكوين شبكة البحث +أنشئ كائن التكوين باستخدام المسارات المحددة: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### الميزة: نشر عقد شبكة البحث +**نظرة عامة**: نشر العقد للتعامل مع عمليات البحث في المستندات بفعالية عبر شبكتك. + +#### الخطوة 1: نشر العقد باستخدام التكوين +انشر عقد شبكة البحث وحدد العقدة الرئيسية للإدارة المركزية: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### الميزة: الاشتراك في أحداث عقد الشبكة +**نظرة عامة**: راقب شبكة البحث بالاشتراك في الأحداث التي تُعلمك بالتغييرات أو الإجراءات المهمة. + +#### الخطوة 1: الاشتراك في أحداث العقدة الرئيسية +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### الميزة: فهرسة المستندات في عقد الشبكة +**نظرة عامة**: أضف دلائل المستندات إلى عملية الفهرسة للحصول على بحث فعال. + +#### الخطوة 1: إضافة دلائل المستندات إلى عملية الفهرسة +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### الميزة: البحث النصي في عقد الشبكة +**نظرة عامة**: تنفيذ عمليات بحث نصية عبر جميع المستندات المفهرسة داخل شبكة البحث. + +#### الخطوة 1: تنفيذ بحث نصي +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### الميزة: تحسين الشظايا +**نظرة عامة**: تعزيز الأداء عبر تحسين الشظايا داخل فهرس عقدة شبكة البحث. + +#### الخطوة 1: تحسين شظايا الفهرس +حسّن الشظايا لتحسين كفاءة البحث (هنا يأتي دور **كيفية تحسين الشظايا** فعليًا): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## التطبيقات العملية +يمكن تطبيق GroupDocs.Search للـ Java في سيناريوهات واقعية متعددة: +1. **إدارة المستندات المؤسسية**: تسهيل استرجاع المستندات عبر قواعد بيانات الشركات الكبيرة. +2. **منصات التجارة الإلكترونية**: تحسين قدرات البحث عن المنتجات باستخدام فهرسة واستعلامات محسّنة. +3. **المكاتب القانونية**: إدارة واسترجاع ملفات القضايا والمستندات من أرشيفات ضخمة بفعالية. +4. **أنظمة المكتبات**: تبسيط عملية الفهرسة عبر التكامل مع أنظمة المكتبات الرقمية للبحث السريع. +5. **أنظمة إدارة المحتوى (CMS)**: تحسين اكتشاف المحتوى من خلال قدرات بحث متقدمة. + +## اعتبارات الأداء +لضمان الأداء المثالي لتطبيق GroupDocs.Search الخاص بك: +- قم بتحسين الشظايا بانتظام لتقليل أوقات استجابة الاستعلامات. +- راقب واُدِر استهلاك الذاكرة، خاصة في البيئات التي تتعامل مع مجموعات بيانات ضخمة. +- اتبع أفضل ممارسات Java لإدارة جمع القمامة والموارد للحفاظ على كفاءة النظام. + +## الخلاصة +باتباع هذا الدليل الشامل، تعلمت كيفية إعداد وتحسين شبكة بحث باستخدام GroupDocs.Search للـ Java. بهذه المهارات، أصبحت قادرًا على تنفيذ عمليات بحث مستندات فعّالة عبر تطبيقات متعددة، مما يعزز أداء مشروعك وتجربة المستخدم. لاستكشاف المزيد من إمكانيات GroupDocs.Search، فكر في دمجها مع أنظمة أخرى أو استكشاف الميزات الإضافية المتوفرة في وثائقهم. + +## قسم الأسئلة المتكررة +1. **ما هو تحسين الشظايا؟** + - تحسين الشظايا يعزز أداء شبكة البحث عبر تنظيم البيانات داخل كل شظية بشكل أكثر كفاءة. +2. **كيف أتعامل مع تعارض المنافذ عند تكوين شبكة البحث؟** + - غيّر المتغير `basePort` إلى منفذ غير مستخدم على نظامك وأعد تشغيل عملية التكوين. +3. **هل يمكن دمج GroupDocs.Search مع تطبيقات Java الحالية؟** + - نعم، يمكن دمجه بسهولة عبر إضافة اعتماد المكتبة إلى مشروعك. +4. **ما هي بعض المشكلات الشائعة التي قد تواجهها أثناء الإعداد؟** + - تشمل المشكلات الشائعة تكوينات المنافذ غير الصحيحة والاعتمادات المفقودة؛ تأكد من اتباع المتطلبات المسبقة بدقة. + +## الأسئلة المتكررة + +**س: كيف يؤثر تحسين الشظايا على سرعة الاستعلام؟** +ج: تحسين الشظايا يضغط الفهرس، يقلل من عمليات الإدخال/الإخراج على القرص، وعادةً ما ينتج عنه استجابات أسرع للاستعلامات. + +**س: هل من الآمن تشغيل `optimizeShards` على عقدة نشطة؟** +ج: نعم، العملية مصممة لتعمل دون توقف، لكن يُفضَّل جدولتها خلال فترات انخفاض الحركة للفهارس الكبيرة. + +**س: هل يمكن تخصيص `OptimizeOptions`؟** +ج: بالتأكيد. يمكنك ضبط معلمات مثل `maxSegmentSize` أو `mergeFactor` لتعديل عملية التحسين وفقًا لاحتياجاتك. + +**س: ماذا أفعل إذا واجهت `IOException` أثناء التحسين؟** +ج: تحقق من أذونات نظام الملفات، تأكد من وجود مساحة كافية على القرص، وتأكد من عدم وجود عملية أخرى تقفل ملفات الفهرس. + +**س: هل يستعيد تحسين الشظايا مساحة المستندات المحذوفة؟** +ج: نعم، يقوم المُحسّن بدمج القطاعات وإزالة "القبور" (tombstones)، مما يحرر المساحة التي كانت مشغولة بالمستندات المحذوفة. + +--- + +**آخر تحديث:** 2026-01-21 +**تم الاختبار مع:** GroupDocs.Search 25.4 للـ Java +**المؤلف:** GroupDocs + +--- \ No newline at end of file diff --git a/content/chinese/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/chinese/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md new file mode 100644 index 00000000..9091148c --- /dev/null +++ b/content/chinese/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -0,0 +1,206 @@ +--- +date: '2026-01-21' +description: 了解如何使用 GroupDocs.Search Java 提高查询性能、向索引添加文档，并在查询时正确转义特殊字符。 +keywords: +- GroupDocs.Search Java +- document index optimization +- search query performance +title: 使用 GroupDocs.Search Java 提升查询性能：优化索引与搜索 +type: docs +url: /zh/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/ +weight: 1 +--- + +# 提升查询性能使用 GroupDocs.Search Java：优化索引与搜索 + +高效管理海量文档始于 **提升查询性能**。在本教程中，您将学习如何创建和配置高性能索引、**将文档添加到索引**，以及正确 **转义特殊字符查询**，从而使搜索快速且返回准确结果。无论是构建企业知识库还是可搜索的电商目录，掌握这些步骤都能让您的应用在高负载下保持响应。 + +## 快速答案 +- **What is the main goal?** 通过微调索引和查询处理来提升查询性能。 +- **Which library is used?** GroupDocs.Search for Java. +- **Do I need a license?** 免费试用或临时许可证足以用于开发；生产环境需要正式许可证。 +- **How do I add documents?** 使用 `index.add("YOUR_DOCUMENT_DIRECTORY")` 批量加载文件。 +- **How are special characters handled?** 在执行搜索前，配置字母表字典并转义字符如 `()\":&|!^~*?`。 + +## 什么是 “提升查询性能”？ +提升查询性能意味着缩短搜索请求在索引中遍历、匹配词项并返回结果所需的时间。通过正确配置索引并准备与之匹配的查询，您可以消除不必要的处理，从而实现更快的响应时间。 + +## 为什么使用 GroupDocs.Search Java 进行高性能搜索？ +- **Scalable indexing** – 处理数百万文档并支持增量更新。 +- **Rich language support** – 内置针对多种字母表和特殊字符的分析器。 +- **Easy integration** – 可与任何基于 Java 的应用程序集成，从 Spring Boot 服务到桌面工具均可使用。 + +## 前提条件 + +在开始之前，请确保已准备好以下内容： + +### 必需的库和依赖 +要在 Maven 项目中使用 GroupDocs.Search，请包含以下配置： + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### 环境设置 +- JDK 8 或更高版本已安装并配置。 +- IDE 如 IntelliJ IDEA 或 Eclipse。 + +### 知识前提 +- 基础 Java 编程。 +- 熟悉 Maven。 +- 了解文档管理概念。 + +## 设置 GroupDocs.Search for Java + +### 1. 通过 Maven 或直接下载安装 +将上面的 XML 代码片段添加到您的 `pom.xml` 中。如果您更喜欢手动方式，可从官方网站下载库： + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### 2. 获取许可证 +您可以在此获取免费试用或临时许可证： + +[GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license) + +### 3. 基本初始化 +创建一个指向索引文件存放文件夹的 `Index` 对象： + +```java +import com.groupdocs.search.*; + +public class SearchInitialization { + public static void main(String[] args) { + Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); + System.out.println("GroupDocs.Search initialized successfully."); + } +} +``` + +## 实施指南 + +### 创建并配置索引 +配置字母表字典可以决定特殊字符的处理方式，这对于 **提升查询性能** 至关重要。 + +#### 步骤 1：初始化索引 +```java +Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); +``` + +#### 步骤 2：配置字符类型 +```java +index.getDictionaries().getAlphabet() + .setRange(new char[] {'&'}, CharacterType.Letter) + .setRange(new char[] {'-'}, CharacterType.Separator); +``` +将 `&` 视为字母、`-` 视为分隔符，可确保搜索引擎按预期解析查询。 + +### 索引文档 +现在让我们 **将文档添加到索引**，使其可被搜索。 + +#### 步骤 3：添加文档 +```java +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` +该方法递归扫描指定文件夹，并索引所有受支持的文件类型。 + +### 准备搜索查询 +要 **转义特殊字符查询**，我们首先根据字母表配置对输入进行标准化，然后添加转义序列。 + +#### 步骤 4：修改特殊字符 +```java +StringBuilder result = new StringBuilder(); +String word = "rock&roll-music"; + +for (int i = 0; i < word.length(); i++) { + char character = word.charAt(i); + CharacterType characterType = index.getDictionaries().getAlphabet().getCharacterType(character); + + if (characterType == CharacterType.Separator) { + result.append(' '); + } else { + result.append(character); + } +} +``` + +#### 步骤 5：转义特殊字符 +```java +String specialCharacters = "()\":&|!^~*?"; +for (int i = result.length() - 1; i >= 0; i--) { + char c = result.charAt(i); + if (specialCharacters.indexOf(c) != -1) { + result.insert(i, '\\'); + } +} +String query = result.toString(); +if (query.contains(" ")) { + query = "\"" + query + "\""; +} +``` +转义可防止解析器将符号误解释为运算符。 + +### 执行搜索 +最后，对准备好的索引执行查询。 + +#### 步骤 6：执行搜索 +```java +import com.groupdocs.search.results.*; + +SearchResult searchResult = index.search(query); +``` +`search` 方法返回一个 `SearchResult` 对象，包含匹配的文档、摘要以及相关性得分。 + +## 实际应用 + +### 案例研究 1：文档管理系统 +律师事务所可通过索引 PDF、Word 文档和电子邮件快速定位案件文件。通过 **提升查询性能**，律师们花在等待结果的时间更少，审阅内容的时间更多。 + +### 案例研究 2：电子商务平台 +在线零售商对产品描述、规格和评论进行索引。正确转义的查询使客户能够搜索诸如 `4‑K TV` 的短语而不出错，同时快速的查询执行保持购物体验流畅。 + +## 性能考虑与技巧 + +- **Refresh the index** 在批量导入或大规模更新后刷新索引，以保持搜索延迟低。 +- **Allocate sufficient heap memory** (`-Xmx2g` 或更高) 以处理大数据集。 +- **Reuse the `Index` instance** 在多次搜索中复用 `Index` 实例，而不是每次重新创建。 +- **Profile query execution** 使用 Java 内置工具对查询执行进行分析，以识别瓶颈。 + +## 常见陷阱与解决方案 + +| 问题 | 原因 | 解决方案 | +|-------|----------------|-----| +| 添加新文件后查询无结果 | 索引未更新 | 调用 `index.add(newPath)` 或重新构建索引。 | +| 出现意外字符错误 | 特殊字符未转义 | 确保在搜索前执行步骤 5 的转义逻辑。 | +| 内存使用过高 | 一次性加载大量结果集 | 惰性遍历 `searchResult.getDocuments()`，或使用 `index.search(query, 100)` 限制结果数量。 | + +## 常见问题解答 + +**Q: 如何使用 GroupDocs.Search 查询中必须转义哪些字符？** +A: The characters `()":&|!^~*?` needindex.add("NEW_DOCUMENT_DIRECTORY")`; the library will merge new entries without rebuilding the whole index. + +**Q: GroupDocs.Search 适用于实时搜索场景吗？** +A‑latency queries, making it ideal for live search boxes. + +## 资源 +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/) + +--- + +**最后更新：** 2026-01-21 +**测试环境：** GroupDocs.Search Java 25.4 +**作者：** GroupDocs \ No newline at end of file diff --git a/content/chinese/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md b/content/chinese/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md new file mode 100644 index 00000000..0aa24614 --- /dev/null +++ b/content/chinese/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md @@ -0,0 +1,216 @@ +--- +date: '2026-01-21' +description: 了解如何添加 GroupDocs Maven 依赖、配置并同步 Java 搜索网络，以及使用 GroupDocs.Search 将目录添加到索引中。 +keywords: +- Java Search Network Configuration +- GroupDocs.Search for Java +- Document Indexing and Retrieval +title: GroupDocs Maven 依赖 – Java 搜索网络同步 +type: docs +url: /zh/java/search-network/java-groupdocs-search-configuration-sync-guide/ +weight: 1 +--- + +# GroupDocs Maven 依赖：配置和同步 Java 搜索网络 + +在本综合指南中，您将了解 **如何将 GroupDocs Maven 依赖** 添加到项目中，然后使用 GroupDocs.Search 配置强大的 Java 搜索网络。无论您处理的是法律简报、财务报告还是学术论文，以下步骤都将帮助您高效地建立索引、搜索并保持分片同步。 + +## Introduction + +管理和搜索海量文档集合是许多组织的日常挑战。通过集成 **GroupDocs Maven 依赖**，您可以获得一个强大的索引引擎，该引擎能够跨多个节点扩展。本教程将引导您完成依赖的设置、网络节点的部署、向索引添加目录以及同步分片以实现最佳性能的全过程。 + +### Quick Answers +- **What is the GroupDocs Maven dependency?** 一个 Maven 构件，将 GroupDocs.Search 库引入您的 Java 项目。 +- **Why use a search network?** 它将索引和查询负载分布到多个节点，提高速度和可靠性。 +- **How do I add directories to index?** 在主节点上使用 `IndexingDocuments.addDirectories`。 +- **How to sync shards?** 在每个节点的 `Indexer` 上调用 `SynchronizeOptions`。 +- **Do I need a license?** 是的，生产环境需要试用或商业许可证。 + +## What is the GroupDocs Maven Dependency? + +GroupDocs Maven 依赖 (`com.groupdocs:groupdocs-search`) 包含构建可搜索索引、管理网络节点以及执行快速查询所需的所有类。将其添加到 `pom.xml` 可确保 Maven 拉取正确的二进制文件及其传递依赖。 + +## How to Add the GroupDocs Maven Dependency + +### Maven Configuration + +将仓库和依赖添加到您的 `pom.xml`： + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +> **Pro tip:** 通过检查官方发布页面，保持版本号为最新。 + +您也可以直接从官方网站下载 JAR：[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/)。 + +## Prerequisites + +- 已安装 **JDK**（11 或更高）。 +- IDE，例如 IntelliJ IDEA 或 Eclipse。 +- 基本的 Java 知识、Maven 使用经验以及对网络节点概念的了解。 +- 有效的 GroupDocs.Search 许可证（免费试用或商业版）。 + +## Basic Initialization and Setup + +首先创建一个索引目录： + +```java +import com.groupdocs.search.SearchIndex; +import com.groupdocs.search.options.IndexingOptions; + +// Create an index in the specified directory +SearchIndex index = new SearchIndex("YOUR_INDEX_DIRECTORY"); +``` + +此简单步骤为后续的网络配置做好准备。 + +## Implementation Guide + +### Feature 1: Configuration of Search Network + +#### Overview + +配置搜索网络时，需要设置节点用于通信的文件路径和端口。 + +##### Set Up Paths and Ports +```java +import com.groupdocs.search.options.*; +import com.groupdocs.search.scaling.configuring.ConfiguringSearchNetwork; + +// Set custom paths for input/output directories +String basePath = "YOUR_DOCUMENT_DIRECTORY/AdvancedUsage/Scaling/SynchronizingShards/"; +int basePort = 49144; // Adjust if there's a port conflict + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` +`configuration` 对象现在包含了搜索网络所需的全部设置。 + +### Feature 2: Deploying Search Network Nodes + +#### Overview + +部署节点以在网络中分配工作负载。主节点负责管理操作和事件。 + +##### Deployment Code +```java +import com.groupdocs.search.scaling.*; +import com.groupdocs.search.options.Configuration; + +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +// Retrieve the master node for further operations +SearchNetworkNode masterNode = nodes[0]; +``` + +### Feature 3: Subscribing to Search Network Node Events + +#### Overview + +监听事件可动态处理网络中的变化或更新。 + +##### Subscription Implementation +```java +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.scaling.SearchNetworkNodeEvents; + +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Feature 4: Adding Directories to Index + +#### Overview + +添加目录是使文档可搜索的核心步骤。 + +##### Document Addition +```java +import com.groupdocs.search.indexing.IndexingDocuments; +import com.groupdocs.search.scaling.SearchNetworkNode; + +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +``` + +### Feature 5: Synchronizing Shards in Search Network Node + +#### Overview + +同步确保所有分片之间的数据一致性。 + +##### Synchronization Code +```java +import com.groupdocs.search.indexing.Indexer; +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.options.SynchronizeOptions; + +SearchNetworkNode node = null; // Assume 'node' is initialized as a SearchNetworkNode + +def synchronizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + SynchronizeOptions options = new SynchronizeOptions(); + indexer.synchronize(options); +} +``` + +### Feature 6: Closing Search Network Nodes + +#### Overview + +正确关闭节点可释放资源并防止内存泄漏。 + +##### Node Closure +```java +import com.groupdocs.search.scaling.SearchNetworkNode; + +for (SearchNetworkNode node : nodes) { + node.close(); +} +``` + +## Practical Applications + +1. **Legal Document Management** – 快速检索案件文件和判例。 +2. **Financial Record Keeping** – 在几秒钟内访问对账单和审计轨迹。 +3. **Academic Research** – 在成千上万的论文中搜索以找到相关引用。 + +## Performance Considerations + +- **Optimize Queries** – 编写简洁的查询以降低响应时间。 +-优 – 根据数据量和查询负载按比例添加节点。 + +## Common Issues and Solutions + +| 问题 | 原因 | 解决方案 | +|-------|-------|----------| +| 节点连接失败 | 端口冲突 | 将 `basePort` 更改为未使用的值 | +| 索引未更新 | 缺少事件订阅 |(masterNode)` | +| 延迟高 | 分片不足 |可以通过 network引新文件夹时，调用 `IndexingDocuments.addDirectories(masterNode, "path")`。 + +**Q: How to sync shards when a new node joins the network?** +A: 在新加入的节点上使用上文展示的 `synchronizeShards` 方法。 + +**Q: Do I need a license for development?** +A: 测试阶段使用免费试用许可证即可，生产环境需要商业许可证。 + +## Conclusion + +通过本指南，您现在已经了解如何 **添加 GroupDocs Maven 依赖**、配置多节点搜索网络、索引目录以及保持分片同步。这些步骤为构建高性能文档搜索解决方案奠定了基础，能够随组织需求的增长而扩展。 + +--- + +**Last Updated:** 2026-01-21 +**Tested With:** GroupDocs.Search 25.4 +**Author:** GroupDocs \ No newline at end of file diff --git a/content/czech/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/czech/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md new file mode 100644 index 00000000..ecba4568 --- /dev/null +++ b/content/czech/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -0,0 +1,215 @@ +--- +date: '2026-01-21' +description: Naučte se, jak zlepšit výkon dotazů a přidávat dokumenty do indexu při + správném escapování speciálních znaků ve dotazu pomocí GroupDocs.Search Java. +keywords: +- GroupDocs.Search Java +- document index optimization +- search query performance +title: 'Zlepšete výkon dotazů s GroupDocs.Search Java: optimalizujte index a vyhledávání' +type: docs +url: /cs/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/ +weight: 1 +--- + +# Zlepšení výkonnosti dotazů s GroupDocs.Search Java: optimalizace indexu a vyhledávání + +Efektivní správa obrovské sbírky dokumentů začíná **zlepšením výkonnosti dotazů**. V tomto tutoriálu se dozvíte, jak vytvořit a nakonfigurovat vysoce výkonný index, **přidat dokumenty do indexu** a správně **uniknout speciálním znakům v dotazu**, aby vyhledávání probíhalo rychle a vracelo přesné výsledky. Ať už budujete firemní znalostní bázi nebo prohledávatelný e‑commerce katalog, zvládnutí těchto kroků zajistí, že vaše aplikace bude pod vysokým zatížením reagovat. + +## Rychlé odpovědi +- **Jaký je hlavní cíl?** Zlepšit výkonnost dotazů laděním indexu a zpracování dotazů. +- **Která knihovna se používá?** GroupDocs.Search pro Java. +- **Potřebuji licenci?** Pro vývoj stačí bezplatná zkušební verze nebo dočasná licence; pro produkci je vyžadována plná licence. +- **Jak přidám dokumenty?** Použijte `index.add("YOUR_DOCUMENT_DIRECTORY")` pro hromadné načtení souborů. +- **Jak se zacházejí se speciálními znaky?** Nakonfigurujte slovník abecedy a unikněte znakům jako `()\":&|!^~*?` před provedením vyhledávání. + +## Co znamená „zlepšení výkonnosti dotazů“? +Zlepšení výkonnosti dotazů znamená snížení času, který trvá, než vyhledávací požadavek projde indexem, najde shody a vrátí výsledky. Správnou konfigurací indexu a přípravou dotazů, které jsou s touto konfigurací sladěny, odstraníte zbytečné zpracování a dosáhnete rychlejších odezvových časů. + +## Proč použít GroupDocs.Search Java pro vysoce výkonné vyhledávání? +- **Škálovatelné indexování** – Zpracovává miliony dokumentů s inkrementálními aktualizacemi. +- **Bohatá podpora jazyků** – Vestavěné analyzátory pro mnoho abeced a speciálních znaků. +- **Jednoduchá integrace** – Funguje s jakoukoliv aplikací založenou na Javě, od služeb Spring Boot po desktopové nástroje. + +## Předpoklady + +Než se pustíme dál, ujistěte se, že máte následující připravené: + +### Požadované knihovny a závislosti +Pro použití GroupDocs.Search v Maven projektu zahrňte následující konfigurace: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Nastavení prostředí +- JDK 8 nebo novější nainstalované a nakonfigurované. +- IDE jako IntelliJ IDEA nebo Eclipse. + +### Předpoklady znalostí +- Základní programování v Javě. +- Znalost Maven. +- Porozumění konceptům správy dokumentů. + +## Nastavení GroupDocs.Search pro Java + +### 1. Instalace přes Maven nebo přímé stažení +Přidejte výše uvedený XML úryvek do svého `pom.xml`. Pokud dáváte přednost ručnímu přístupu, stáhněte knihovnu z oficiálního webu: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### 2. Získání licence +Bezplatnou zkušební verzi nebo dočasnou licenci můžete získat zde: + +[GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license) + +### 3. Základní inicializace +Vytvořte objekt `Index`, který ukazuje na složku, kde budou uloženy soubory indexu: + +```java +import com.groupdocs.search.*; + +public class SearchInitialization { + public static void main(String[] args) { + Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); + System.out.println("GroupDocs.Search initialized successfully."); + } +} +``` + +## Průvodce implementací + +### Vytvoření a konfigurace indexu +Konfigurace slovníku abecedy vám umožní rozhodnout, jak budou speciální znaky zpracovány, což je nezbytné pro **zlepšení výkonnosti dotazů**. + +#### Krok 1: Inicializace indexu +```java +Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); +``` + +#### Krok 2: Konfigurace typů znaků +```java +index.getDictionaries().getAlphabet() + .setRange(new char[] {'&'}, CharacterType.Letter) + .setRange(new char[] {'-'}, CharacterType.Separator); +``` +Zacházení s `&` jako s písmenem a `-` jako s oddělovačem zajišťuje, že vyhledávač parsuje dotazy tak, jak očekáváte. + +### Indexování dokumentů +Nyní **přidáme dokumenty do indexu**, aby byly prohledávatelné. + +#### Krok 3: Přidávání dokumentů +```java +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` +Metoda rekurzivně prohledá zadanou složku a indexuje každý podporovaný typ souboru. + +### Příprava vyhledávacího dotazu +Pro **uniknutí speciálním znakům v dotazu** nejprve normalizujeme vstup podle konfigurace abecedy a poté přidáme únikové sekvence. + +#### Krok 4: Úprava speciálních znaků +```java +StringBuilder result = new StringBuilder(); +String word = "rock&roll-music"; + +for (int i = 0; i < word.length(); i++) { + char character = word.charAt(i); + CharacterType characterType = index.getDictionaries().getAlphabet().getCharacterType(character); + + if (characterType == CharacterType.Separator) { + result.append(' '); + } else { + result.append(character); + } +} +``` + +#### Krok 5: Uniknutí speciálních znaků +```java +String specialCharacters = "()\":&|!^~*?"; +for (int i = result.length() - 1; i >= 0; i--) { + char c = result.charAt(i); + if (specialCharacters.indexOf(c) != -1) { + result.insert(i, '\\'); + } +} +String query = result.toString(); +if (query.contains(" ")) { + query = "\"" + query + "\""; +} +``` +Uniknutí zabraňuje parseru špatně interpretovat symboly jako operátory. + +### Provedení vyhledávání +Nakonec spusťte dotaz proti připravenému indexu. + +#### Krok 6: Provedení vyhledávání +```java +import com.groupdocs.search.results.*; + +SearchResult searchResult = index.search(query); +``` + +## Praktické aplikace + +### Případová studie 1: Systémy správy dokumentů +Právnické firmy mohou rychle najít spisové soubory indexováním PDF, Word dokumentů a e‑mailů. **Zlepšením výkonnosti dotazů** tráví právníci méně času čekáním na výsledky a více času revizí obsahu. + +### Případová studie 2: E‑commerce platformy +Online prodejci indexují popisy produktů, specifikace a recenze. Správně uniknuté dotazy umožňují zákazníkům vyhledávat fráze jako `4‑K TV` bez chyb, zatímco rychlé provedení dotazu udržuje plynulý nákupní zážitek. + +## Úvahy o výkonu a tipy + +- **Obnovte index** po hromadných importech nebo velkých aktualizacích, aby byla latence vyhledávání nízká. +- **Přidělte dostatečnou haldu** (`-Xmx2g` nebo vyšší) pro velké datové sady. +- **Znovu použijte instanci `Index`** napříč více vyhledáváními místo jejího opakovaného vytváření. +- **Profilujte provádění dotazů** pomocí vestavěných nástrojů Javy k identifikaci úzkých míst. + +## Časté úskalí a řešení + +| Problém | Proč se to děje | Řešení | +|-------|----------------|-----| +| Dotazy nevracejí žádné výsledky po přidání nových souborů | Index není aktualizován | Zavolejte `index.add(newPath)` nebo znovu vytvořte index. | +| Chyby o neočekávaných znacích | Speciální znaky nejsou uniknuty | Ujistěte se, že logika unikání ze Krok 5 běží před vyhledáváním. | +| Vysoká spotřeba paměti | Velké sady výsledků jsou načteny najednou | Iterujte přes `searchResult.getDocuments()` líně nebo omezte výsledky pomocí `index.search(query, 100)`. | + +## Často kladené otázky + +**Q: Jak mohu pracovat s extrémně velkými datovými sadami pomocí GroupDocs.Search?** +A: Používejte inkrementální indexování (`index.add`) a naplánujte periodické optimalizace indexu. Nasazujte index na SSD úložiště pro rychlejší I/O. + +**Q: Lze GroupDocs.Search integrovat se Spring Boot?** +A: Ano. Definujte bean `Index` ve třídě `@Configuration` a injektujte jej tam, kde potřebujete vyhledávací funkce. + +**Q: Které znaky je třeba v dotazu uniknout?** +A: Znaky `()":&|!^~*?` vyžadují předchozí zpětné lomítko (`\`), aby byly považovány za literály. + +**Q: Jak mohu aktualizovat existující index nově nahranými dokumenty?** +A: Zavolejte `index.add("NEW_DOCUMENT_DIRECTORY")`; knihovna sloučí nové položky bez nutnosti přestavování celého indexu. + +**Q: Je GroupDocs.Search vhodný pro scénáře vyhledávání v reálném čase?** +A: Rozhodně. Knihovna podporuje rychlé inkrement## Zdroje +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/) + +--- + +**Poslední aktualizace:** 2026-01-21 +**Testováno s:** GroupDocs.Search Java 25.4 +**Autor:** GroupDocs + +--- \ No newline at end of file diff --git a/content/czech/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/czech/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..5d44f1a2 --- /dev/null +++ b/content/czech/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,190 @@ +--- +date: '2026-01-21' +description: Naučte se, jak optimalizovat shardy pomocí GroupDocs.Search pro Javu, + jak nakonfigurovat vyhledávací síť, provádět textové vyhledávání a řešit konflikty + portů. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Jak optimalizovat shardy v GroupDocs.Search pro Javu: komplexní průvodce' +type: docs +url: /cs/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# Jak optimalizovat shardy v GroupDocs.Search pro Java:ledávání dokumentů je nezbytné pro vývojáře a firmy spravující velké databáze nebo usilující o zjednodušení interních procesů vyhledávání dokumentů. Pokud se ptáte **jak optimalizovatů? dot port, poté nasadíte uzly pomocí poskytovaného API. +- **Jak provést textové vyhledávání?** Použijte `TextSearchInNetwork.searchAll` s vaším řetězcem dotazu. +- **Jak indexovat dokumenty v Javě?** Přidejte adresáře dokumentů do hlavního uzlu pomocí `IndexingDocuments.addDirectories`. +- **Jak řešit konflikty portů?** Změňte proměnnou `basePort` na nepoužívaný port ve vašem počítači. + +## How to Configure Search Network +Než se pustíte do indexování a vyhledávání, potřebujete pevný základ sítě. Tato sekce vysvětluje kroky k nastavení sítě, výběru portu a vyhnutí se běžným problémům s konflikty portů. + +## How to Index Documents Java +Jakmile je síť spuštěna, dalším krokem je naplnit ji obsahem. Ukážeme vám, jak přidat více složek s dokumenty, aby engine mohl vytvořit prohledávatelný index. + +## How to Perform Text Search +Po indexování budete chtít rychle získat informace. Tato část ukazuje nejjednodušší způsob, jak spustit textový dotaz napříč všemi uzly. + +## How to Handle Port Conflicts +Pokud je výchozí port (`49132`) již používán, jednoduše změňte hodnotu `basePort` na volný port a restartujte konfiguraci. Tím se zabrání chybám při spouštění a síť zůstane stabilní. + +## Prerequisites +Než začneme, ujistěte se, že máte následující předpoklady připravené: + +### Required Libraries, Versions, and Dependencies +Pro implementaci tohoto řešení zahrňte knihovnu GroupDocs.Search pomocí Maven přidáním následující konfigurace do souboru `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Alternativně si stáhněte nejnovější verzi z [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Environment Setup Requirements +- Ujistěte se, že vaše vývojové prostředí podporuje Java (JDK 8 nebo novější). +- Přístup k síťové konfiguraci umožňující používání portů. + +### Knowledge Prerequisites +Základní pochopení programování v Javě, včetně objektově orientovaných principů a zpracování výjimek, bude pro tento tutoriál užitečné. + +## Setting Up GroupDocs.Search for Java +Pro zahájení používání GroupDocs.Search ve vašem projektu postupujte podle následujících kroků: + +1. **Přidejte závislost**: Jak je uvedeno výše, přidejte potřebnou Maven závislost do svého projektu nebo stáhněte přímo ze stránky s vydáními. + +2. **Získání licence**: + - Pro bezplatnou zkušební verzi používejte knihovnu bez omezení funkcí, ale s určitými omezeními využití. + - Získejte dočasnou licenci pro plný přístup k funkcím během hodnocení návštěvou [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/). + - Zakupte plnou licenci, pokud se rozhodnete integrovat GroupDocs.Search do produkčního prostředí. + +3. **Základní inicializace a nastavení**: + Inicializujte konfiguraci pomocí třídy `Configuration`, nastavte základní cestu pro dokumenty a specifikujte číslo portu: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Implementation Guide +Nyní prozkoumejme implementaci klíčových funkcí pomocí GroupDocs.Search Java. + +### Feature: Configuring Search Network +**Přehled**: Nastavení vyhledávací sítě zahrnuje definování adresáře s dokumenty a jeho konfiguraci s konkrétním portem pro komunikaci mezi uzly. + +#### Step 1: Define Document Directories and Port +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Step 2: Configure Search Network +Vytvořte konfigurační objekt pomocí definovaných cest: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Feature: Deploying Search Network Nodes +**Přehled**: Nasazujte uzly pro efektivní zpracování vyhledávání dokumentů napříč vaší sítí. + +#### Step 1: Deploy Nodes Using Configuration +Nasazujte uzly vyhledávací sítě a identifikujte hlavní uzel pro centralizovanou správu: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Feature: Subscribing to Network Node Events +**Přehled**: Monitorujte vaši vyhledávací síť přihlášením k událostem, které vás upozorní na důležité změny nebo akce. + +#### Step 1: Subscribe to Master Node Events +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Feature: Indexing Documents in Network Nodes +**Přehled**: Přidejte adresáře obsahující dokumenty do procesu indexování pro efektivní vyhledávání. + +#### Step 1: Add Document Directories to Indexing Process +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Feature: Text Search in Network Nodes +**Přehled**: Proveďte textové vyhledávání napříč všemi indexovanými dokumenty ve vaší vyhledávací síti. + +#### Step 1: Perform a Text Search +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Feature: Optimizing Shards +**Přehled**: Zlepšete výkon optimalizací shardů v indexeru vašeho uzlu vyhledávací sítě. + +#### Step 1: Optimize Indexer Shards +Optimalizujte shardy pro zlepšení efektivity vyhled (tady je **jak optimalizovat shardy** opravdu důležité): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Practical Applications +GroupDocs.Search pro Java lze použít v různých reálných scénářích: + +1. **Enterprise Document Management**: Umožněte vyhledávání dokumentů napříč velkými firemními databázemi. +2. **E‑commerce Platforms**: Zlepšete možnosti vyhledávání produktů pomocí optimalizovaného indexování a dotazovacích funkcí. +3. **Legal Firms**: Efektivně spravujte a vyhledávejte soudní spisy a dokumenty z rozsáhlých archivů. +4. **Library Systems**: Zjednodušte proces katalogizace integrací s digitálními knihovními systémy pro rychlé vyhledávání. +5. **Content Management Systems (CMS)**: Zlepšete objevitelnost obsahu pomocí pokročilých vyhledávacích možností. + +## Performance Considerations +Pro zajištění optimálního výkonu vaší implementace GroupDocs.Search: + +- Pravidelně optimalizujte shardy ke snížení doby odezvy dotazů. +- Sledujte a spravujte využití paměti, zejména v prostředích pracujících s velkými datovými sadami. +- Dodržujte osvěditek. Prote integraci s jinými systémy nebo prozkoumání dalších funkcí dostupných v jejich dokumentaci. + +## FAQ Section +1. **Co je optimalizace shardů?** - Optimalizace shardů zlepšuje výkon vyhledávací sítě organizací dat efektivněji v každém shardu. +2. **Jak řešit konflikty portů při konfiguraci vyhledávací sítě?** - Změňte proměnnou basePort na nepoužívaný port ve vašem systému a zahrnut4. **Jaké jsou běžné problémy při nastavení?** - Běžné problémy zahrnují nesprávné konfigurace portů a chybějící závislosti; ujistěte se, že přes je navržena tak, aby běžela bez výpadku, ale je vhodné ji naplánovat během období nízkého provozu u velkých indexů. + + neboizace. + +**Q: Co mám dělat, pokud během optimalizace narazím na `IOException`?** +**A:** Ověřte oprávnění souborového systému, zajistěte dostatek místa na disku a potvrďte, že žádný jiný proces neblokuje soubory indexu. + +**Q: Získává optimalizace shardů také zpět místo po smazaných dokumentech?** +**A:** Ano, optimalizátor sloučí segmenty a odstraní tombstone, čímž uvolní místo obsazené smazanými dokumenty. + +--- + +**Poslední \ No newline at end of file diff --git a/content/dutch/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/dutch/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md new file mode 100644 index 00000000..bb0b43c9 --- /dev/null +++ b/content/dutch/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -0,0 +1,220 @@ +--- +date: '2026-01-21' +description: Leer hoe u de query‑prestaties kunt verbeteren en documenten aan de index + kunt toevoegen, terwijl u speciale tekens in de query correct escape met GroupDocs.Search + Java. +keywords: +- GroupDocs.Search Java +- document index optimization +- search query performance +title: 'Verbeter de queryprestaties met GroupDocs.Search Java: optimaliseer index + en zoeken' +type: docs +url: /nl/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/ +weight: 1 +--- + +# Verbeter Queryprestaties met GroupDocs.Search Java: Index & Zoeken Optimaliseren + +Het efficiënt beheren van een enorme verzameling documenten begint met **verbeteren van queryprestaties**. In deze tutorial ontdek je hoe je een high‑performance index maakt en configureert, **documenten aan de index toevoegt**, en correct **speciale tekens in een query escape** zodat zoekopdrachten snel verlopen en nauwkeurige resultaten opleveren. Of je nu een bedrijfs‑kennisbank of een doorzoekbare e‑commercecatalogus bouwt, het beheersen van deze stappen houdt je applicatie responsief onder zware belasting. + +## Quick Answers +- **Wat is het belangrijkste doel?** Verbeter queryprestaties door de index en query‑afhandeling fijn af te stemmen. +- **Welke bibliotheek wordt gebruikt?** GroupDocs.Search voor Java. +- **Heb ik een licentie nodig?** Een gratis proefversie of tijdelijke licentie is voldoende voor ontwikkeling; een volledige licentie is vereist voor productie. +- **Hoe voeg ik documenten toe?** Gebruik `index.add("YOUR_DOCUMENT_DIRECTORY")` om bestanden in bulk te laden. +- **Hoe worden speciale tekens behandeld?** Configureer het alfabet‑woordenboek en escape tekens zoals `()\":&|!^~*?` voordat je de zoekopdracht uitvoert. + +## Wat betekent “verbeteren van queryprestaties”? +Verbeteren van queryprestaties betekent de tijd verkorten die een zoekverzoek nodig heeft om door de index te reizen, termen te matchen en resultaten terug te geven. Door de index correct te configureren en queries voor te bereiden die op die configuratie aansluiten, elimineer je onnodige verwerking en behaal je snellere responstijden. + +## Waarom GroupDocs.Search Java gebruiken voor high‑performance zoekopdrachten? +- **Schaalbare indexering** – Verwerkt miljoenen documenten met incrementele updates. +- **Rijke taalondersteuning** – Ingebouwde analyzers voor veel alfabetten en speciale tekens. +- **Eenvoudige integratie** – Werkt met elke Java‑gebaseerde applicatie, van Spring Boot‑services tot desktop‑tools. + +## Prerequisites + +Voordat we beginnen, zorg ervoor dat je het volgende klaar hebt: + +### Required Libraries and Dependencies +Om GroupDocs.Search in een Maven‑project te gebruiken, voeg je de volgende configuraties toe: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Environment Setup +- JDK 8 of nieuwer geïnstalleerd en geconfigureerd. +- IDE zoals IntelliJ IDEA of Eclipse. + +### Knowledge Prerequisites +- Basis Java‑programmeren. +- Vertrouwdheid met Maven. +- Begrip van document‑beheerconcepten. + +## Setting Up GroupDocs.Search for Java + +### 1. Install via Maven or Direct Download +Voeg de XML‑snippet hierboven toe aan je `pom.xml`. Als je de voorkeur geeft aan een handmatige aanpak, download dan de bibliotheek van de officiële site: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### 2. Acquire a License +Je kunt hier een gratis proefversie of een tijdelijke licentie verkrijgen: + +[GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license) + +### 3. Basic Initialization +Maak een `Index`‑object aan dat wijst naar een map waar de indexbestanden worden opgeslagen: + +```java +import com.groupdocs.search.*; + +public class SearchInitialization { + public static void main(String[] args) { + Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); + System.out.println("GroupDocs.Search initialized successfully."); + } +} +``` + +## Implementation Guide + +### Creating and Configuring an Index +Het configureren van het alfabet‑woordenboek laat je bepalen hoe speciale tekens worden behandeld, wat essentieel is voor **verbeteren van queryprestaties**. + +#### Step 1: Initialize Index +```java +Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); +``` + +#### Step 2: Configure Character Types +```java +index.getDictionaries().getAlphabet() + .setRange(new char[] {'&'}, CharacterType.Letter) + .setRange(new char[] {'-'}, CharacterType.Separator); +``` +Het behandelen van `&` als een letter en `-` als een scheidingsteken zorgt ervoor dat de zoekmachine queries parseert zoals jij verwacht. + +### Indexing Documents +Laten we nu **documenten aan de index toevoegen** zodat ze doorzoekbaar worden. + +#### Step 3: Adding Documents +```java +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` +De methode scant de opgegeven map recursief en indexeert elk ondersteund bestandstype. + +### Preparing the Search Query +Om **speciale tekens in een query te escapen**, normaliseren we eerst de invoer op basis van de alfabetconfiguratie, en voegen vervolgens escape‑reeksen toe. + +#### Step 4: Modify Special Characters +```java +StringBuilder result = new StringBuilder(); +String word = "rock&roll-music"; + +for (int i = 0; i < word.length(); i++) { + char character = word.charAt(i); + CharacterType characterType = index.getDictionaries().getAlphabet().getCharacterType(character); + + if (characterType == CharacterType.Separator) { + result.append(' '); + } else { + result.append(character); + } +} +``` + +#### Step 5: Escape Special Characters +```java +String specialCharacters = "()\":&|!^~*?"; +for (int i = result.length() - 1; i >= 0; i--) { + char c = result.charAt(i); + if (specialCharacters.indexOf(c) != -1) { + result.insert(i, '\\'); + } +} +String query = result.toString(); +if (query.contains(" ")) { + query = "\"" + query + "\""; +} +``` +Escapen voorkomt dat de parser symbolen verkeerd interpreteert als operatoren. + +### Executing the Search +Voer tenslotte de query uit tegen de voorbereide index. + +#### Step 6: Execute Search +```java +import com.groupdocs.search.results.*; + +SearchResult searchResult = index.search(query); +``` +De `search`‑methode retourneert een `SearchResult`‑object met overeenkomende documenten, fragmenten en relevantiescores. + +## Practical Applications + +### Case Study 1: Document Management Systems +Advocatenkantoren kunnen snel dossiers vinden door PDFs, Word‑documenten en e‑mails te indexeren. Door **queryprestaties te verbeteren**, besteden advocaten minder tijd aan wachten op resultaten en meer tijd aan het beoordelen van inhoud. + +### Case Study 2: E‑commerce Platforms +Online retailers index productbeschrijvingen, specificaties en recensies. Correct geescaped queries stellen klanten in staat om te zoeken naar zinnen zoals `4‑K TV` zonder fouten, terwijl snelle query‑uitvoering de winkelervaring soepel houdt. + +## Performance Considerations & Tips + +- **Ververs de index** na bulk‑importen of grote updates om de zoeklatentie laag te houden. +- **Wijs voldoende heap‑geheugen toe** (`-Xmx2g` of hoger) voor grote datasets. +- **Herbruik de `Index`‑instantie** voor meerdere zoekopdrachten in plaats van deze elke keer opnieuw te maken. +- **Profileer query‑uitvoering** met Java’s ingebouwde tools om knelpunten te identificeren. + +## Common Pitfalls & Solutions + +| Probleem | Waarom het gebeurt | Oplossing | +|----------|--------------------|-----------| +| Queries geven geen resultaten na het toevoegen van nieuwe bestanden | Index niet bijgewerkt | Roep `index.add(newPath)` aan of bouw de index opnieuw. | +| Fouten over onverwachte tekens | Speciale tekens niet geescaped | Zorg ervoor dat de escape‑logica uit Stap 5 wordt uitgevoerd vóór het zoeken. | +| Hoge geheugengebruik | Grote resultaatsverzamelingen in één keer geladen | Itereer lui over `searchResult.getDocuments()` of beperk resultaten met `index.search(query, 100)`. | + +## Frequently Asked Questions + +**V: Hoe ga ik om met extreem grote datasets met GroupDocs.Search?** +Ja. Gebruik incrementele indexering (`index.add`) en plan periodieke indexoptimalisaties. Zet de index op SSD‑opslag voor snellere I/O. + +**V: Kan GroupDocs.Search worden geïntegreerd met Spring Boot?** +Ja. Definieer de `Index`‑bean in een `@Configuration`‑klasse en injecteer deze waar je zoekfunctionaliteit nodig hebt. + +**V: Welke tekens moeten in een query worden geescaped?** +De tekens `()\":&|!^~*?` hebben een voorafgaande backslash (`\`) nodig om als letterlijke tekens te worden behandeld. + +**V: Hoe kan ik een bestaande index bijwerken met nieuw geüploade documenten?** +Roep `index.add("NEW_DOCUMENT_DIRECTORY")` aan; de bibliotheek zal nieuwe items samenvoegen zonder de hele index opnieuw op te bouwen. + +**V: Is GroupDocs.Search geschikt voor real‑time zoekscenario's?** +Absoluut. De bibliotheek ondersteunt snelle incrementele updates en queries met lage latentie, waardoor hij ideaal is voor live zoekvelden. + +## Resources +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/) + +--- + +**Last Updated:** 2026-01-21 +**Tested With:** GroupDocs.Search Java 25.4 +**Author:** GroupDocs + +--- \ No newline at end of file diff --git a/content/dutch/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md b/content/dutch/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md new file mode 100644 index 00000000..79ab07ce --- /dev/null +++ b/content/dutch/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md @@ -0,0 +1,224 @@ +--- +date: '2026-01-21' +description: Leer hoe je de GroupDocs Maven‑dependency toevoegt, een Java‑zoeknetwerk + configureert en synchroniseert, en mappen toevoegt aan de index met GroupDocs.Search. +keywords: +- Java Search Network Configuration +- GroupDocs.Search for Java +- Document Indexing and Retrieval +title: GroupDocs Maven-afhankelijkheid – Java-zoeknetwerksynchronisatie +type: docs +url: /nl/java/search-network/java-groupdocs-search-configuration-sync-guide/ +weight: 1 +--- + +# GroupDocs Maven Dependency: Configureren en Synchroniseren van Java‑zoeknetwerken + +In deze uitgebreide gids ontdek je **hoe je de GroupDocs Maven‑dependency** aan je project toevoegt en vervolgens een robuust Java‑zoeknetwerk configureert met GroupDocs.Search. Of je nu juridische stukken, financiële rapporten of academische papers verwerkt, de onderstaande stappen helpen je om efficiënt te indexeren, zoeken en je shards gesynchroniseerd te houden. + +## Inleiding + +Het beheren en doorzoeken van enorme documentcollecties is een dagelijkse uitdaging voor veel organisaties. Door de **GroupDocs Maven‑dependency** te integreren, krijg je toegang tot een krachtige indexeringsengine die over meerdere knooppunten schaalt. Deze tutorial leidt je door het instellen van de dependency, het uitrollen van netwerk‑knooppunten, het toevoegen van mappen aan de index en het synchroniseren van shards voor optimale prestaties. + +### Snelle antwoorden +- **Wat is de GroupDocs Maven‑dependency?** Een Maven‑artifact dat de GroupDocs.Search‑bibliotheek in je Java‑project brengt. +- **Waarom een zoeknetwerk gebruiken?** Het verdeelt index‑ en query‑belasting over meerdere knooppunten, waardoor snelheid en betrouwbaarheid toenemen. +- **Hoe voeg ik mappen toe aan de index?** Gebruik `IndexingDocuments.addDirectories` op het master‑knooppunt. +- **Hoe synchroniseer ik shards?** Roep `SynchronizeOptions` aan op de `Indexer` van elk knooppunt. +- **Heb ik een licentie nodig?** Ja, een proef‑ of commerciële licentie is vereist voor productiegebruik. + +## Wat is de GroupDocs Maven Dependency? + +De GroupDocs Maven‑dependency (`com.groupdocs:groupdocs-search`) bevat alle klassen die je nodig hebt om doorzoekbare indexen te bouwen, netwerk‑knooppunten te beheren en snelle queries uit te voeren. Het toevoegen aan je `pom.xml` zorgt ervoor dat Maven de juiste binaries en transitieve dependencies downloadt. + +## Hoe voeg je de GroupDocs Maven Dependency toe + +### Maven‑configuratie + +Voeg de repository en dependency toe aan je `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +> **Pro tip:** Houd het versienummer actueel door de officiële releases‑pagina te raadplegen. + +Je kunt de JAR ook direct downloaden van de officiële site: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +## Vereisten + +- **JDK** (11 of hoger) geïnstalleerd. +- Een IDE zoals IntelliJ IDEA of Eclipse. +- Basiskennis van Java, Maven en een begrip van netwerk‑knooppuntconcepten. +- Een geldige GroupDocs.Search‑licentie (gratis proefversie of commercieel). + +## Basisinitialisatie en -setup + +Begin met het aanmaken van een indexmap: + +```java +import com.groupdocs.search.SearchIndex; +import com.groupdocs.search.options.IndexingOptions; + +// Create an index in the specified directory +SearchIndex index = new SearchIndex("YOUR_INDEX_DIRECTORY"); +``` + +Deze eenvoudige stap bereidt de omgeving voor op de daaropvolgende netwerkconfiguratie. + +## Implementatie‑gids + +### Functie 1: Configuratie van het zoeknetwerk + +#### Overzicht + +Het configureren van het zoeknetwerk stelt de bestands‑paden en poorten in die knooppunten gebruiken om te communiceren. + +##### Paden en poorten instellen +```java +import com.groupdocs.search.options.*; +import com.groupdocs.search.scaling.configuring.ConfiguringSearchNetwork; + +// Set custom paths for input/output directories +String basePath = "YOUR_DOCUMENT_DIRECTORY/AdvancedUsage/Scaling/SynchronizingShards/"; +int basePort = 49144; // Adjust if there's a port conflict + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` +Het `configuration`‑object bevat nu alle benodigde instellingen voor je zoeknetwerk. + +### Functie 2: Uitrollen van zoeknetwerk‑knooppunten + +#### Overzicht + +Rol knooppunten uit om de werklast over je netwerk te verdelen. Het master‑knooppunt beheert operaties en gebeurtenissen. + +##### Deploy‑code +```java +import com.groupdocs.search.scaling.*; +import com.groupdocs.search.options.Configuration; + +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +// Retrieve the master node for further operations +SearchNetworkNode masterNode = nodes[0]; +``` + +### Functie 3: Abonneren op zoeknetwerk‑knooppunt‑events + +#### Overzicht + +Luisteren naar events maakt dynamische afhandeling van wijzigingen of updates in je netwerk mogelijk. + +##### Implementatie van abonnement +```java +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.scaling.SearchNetworkNodeEvents; + +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Functie 4: Mappen toevoegen aan de index + +#### Overzicht + +Mappen toevoegen is de kernstap die je documenten doorzoekbaar maakt. + +##### Documenten toevoegen +```java +import com.groupdocs.search.indexing.IndexingDocuments; +import com.groupdocs.search.scaling.SearchNetworkNode; + +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +``` + +### Functie 5: Shards synchroniseren in zoeknetwerk‑knooppunt + +#### Overzicht + +Synchronisatie zorgt voor gegevensconsistentie over alle shards. + +##### Synchronisatiecode +```java +import com.groupdocs.search.indexing.Indexer; +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.options.SynchronizeOptions; + +SearchNetworkNode node = null; // Assume 'node' is initialized as a SearchNetworkNode + +def synchronizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + SynchronizeOptions options = new SynchronizeOptions(); + indexer.synchronize(options); +} +``` + +### Functie 6: Zoeknetwerk‑knooppunten sluiten + +#### Overzicht + +Het correct afsluiten van knooppunten geeft bronnen vrij en voorkomt geheugenlekken. + +##### Knooppunt‑sluiting +```java +import com.groupdocs.search.scaling.SearchNetworkNode; + +for (SearchNetworkNode node : nodes) { + node.close(); +} +``` + +## Praktische toepassingen + +1. **Beheer van juridische documenten** – Haal snel dossiers en precedenten op. +2. **Financiële administratie** – Toegang tot afschriften en audit‑trails in seconden. +3. **Academisch onderzoek** – Doorzoek duizenden papers om relevante citaten te vinden. + +## Prestatie‑overwegingen + +- **Queries optimaliseren** – Schrijf beknopte queries om responstijd te verkorten. +- **Geheugenbeheer** – Houd JVM‑heapgebruik in de gaten; overweeg GC‑afstemming voor grote indexen. +- **Schaalstrategie** – Voeg knooppunten proportioneel toe aan datavolume en query‑belasting. + +## Veelvoorkomende problemen en oplossingen + +| Probleem | Oorzaak | Oplossing | +|----------|---------|-----------| +| Knooppunten kunnen niet verbinden | Poortconflict | Verander `basePort` naar een ongebruikte waarde | +| Index wordt niet bijgewerkt | Event‑abonnement ontbreekt | Zorg dat `SearchNetworkNodeEvents.subscribe(masterNode)` wordt aangeroepen | +| Hoge latentie | Onvoldoende shards | Verhoog hetwerk?** +A: Ja, je kunt aangepaste paden, poorten en andere opties instellen via het `Configuration`‑object. + +**V: Hoe voeg ik mappen toe aan de index nadat het netwerk draait?** +A: Roep `IndexingDocuments.addDirectories(masterNode, "path")` aan wanneer je nieuwe folders wilt indexeren. + +**V: Hoe synchroniseer ik shards wanneer een nieuw knooppunt het netwerk toetreedt?** +A: Gebruik de hierboven getoonde `synchronizeShards`‑methode op het nieuw toegevoegde knooppunt. + +**V: Heb ik een licentie nodig voor ontwikkeling?** +A: Een gratis proeflicentie is voldoende voor testen; een commerciële licentie is vereist voor productie. + +## Conclusie + +Door deze gids te volgen weet je nu **hoe je de GroupDocs Maven‑dependency toevoegt**, een multi‑node zoeknetwerk configureert, mappen indexeert en shards gesynchroniseerd houdt. Deze stappen vormen de basis voor een high‑performance document‑zoekoplossing die kan meegroeien met de behoeften van je organisatie. + +--- + +**Laatst bijgewerkt:** 2026-01-21 +**Getest met:** GroupDocs.Search 25.4 +**Auteur:** GroupDocs + +--- \ No newline at end of file diff --git a/content/dutch/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/dutch/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..be05ba83 --- /dev/null +++ b/content/dutch/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,213 @@ +--- +date: '2026-01-21' +description: Leer hoe je shards optimaliseert met GroupDocs.Search voor Java en hoe + je het zoeknetwerk configureert, tekstzoekopdrachten uitvoert en poortconflicten + afhandelt. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Hoe shards te optimaliseren in GroupDocs.Search voor Java: een uitgebreide + gids' +type: docs +url: /nl/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# Hoe Shards te Optimaliseren in GroupDocs.Search voor Java: Een Uitgebreide Gids + +Efficiënt document zoeken is essentieel voor ontwikkelaars en bedrijven die grote databases beheren of interne documentophaalprocessen willen stroomlijnen. Als je je afvraagt **hoe je shards optimaliseert**, zal deze gids je stap voor stap begeleiden om de prestaties te verbeteren, je zoeknetwerk te configureren en veelvoorkomende uitdagingen zoals poortconflicten aan te pakken. **GroupDocs.Search Java** biedt naadloze configuratie en optimalisatie van je zoeknetwerk, waardoor zowel de prestaties als de gebruikerservaring worden verbeterd. + +## Snelle Antwoorden +- **Wat is shard-optimalisatie?** Het reorganiseert indexgegevens om queries te versnellen en de opslagbelasting te verminderen. +- **Hoe configureer je een zoeknetwerk?** Definieer een basisdirectory en poort, en zet vervolgens knooppunten in via de meegeleverde API. +- **Hoe voer je een tekstzoekopdracht uit?** Gebruik `TextSearchInNetwork.searchAll` met je query‑string. +- **Hoe indexeer je documenten in Java?** Voeg documentdirectories toe aan de master‑node met `IndexingDocuments.addDirectories`. +- **Hoe ga je om met poortconflicten?** Verander de `basePort`‑variabele naar een ongebruikte poort op je machine. + +## Hoe een Zoeknetwerk te Configureren +Voordat je aan indexeren en zoeken begint, heb je een solide netwerkinfrastructuur nodig. Deze sectie legt de stappen uit om het netwerk op te zetten, een poort te kiezen en veelvoorkomende poort‑conflictproblemen te vermijden. + +## Hoe Documenten te Indexeren in Java +Zodra het netwerk operationeel is, is de volgende stap om het van inhoud te voorzien. We laten je zien hoe je meerdere documentmappen kunt toevoegen zodat de engine een doorzoekbare index kan bouwen. + +## Hoe Tekstzoekopdrachten uit te Voeren +Na het indexeren wil je informatie snel kunnen ophalen. Dit onderdeel toont de eenvoudigste manier om een tekstquery uit te voeren over alle knooppunten. + +## Hoe om te Gaan met Poortconflicten +Als de standaardpoort (`49132`) al in gebruik is, wijzig dan eenvoudig de `basePort`‑waarde naar een vrije poort en herstart de configuratie. Dit voorkomt opstartfouten en houdt je netwerk stabiel. + +## Voorvereisten +Zorg er voordat we beginnen voor dat je de volgende voorvereisten hebt: + +### Vereiste Bibliotheken, Versies en Afhankelijkheden +Om deze oplossing te implementeren, voeg je de GroupDocs.Search‑bibliotheek toe via Maven door de volgende configuratie aan je `pom.xml`‑bestand toe te voegen: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Download anders de nieuwste versie van [GroupDocs.Search voor Java releases](https://releases.groupdocs.com/search/java/). + +### Vereisten voor Omgevingsconfiguratie +- Zorg ervoor dat je ontwikkelomgeving Java ondersteunt (JDK 8 of hoger). +- Toegang tot een netwerkconfiguratie die poortgebruik toestaat. + +### Kennisvoorvereisten +Een basisbegrip van Java‑programmeren, inclusief object‑georiënteerde principes en exception‑handling, is nuttig voor deze tutorial. + +## GroupDocs.Search voor Java Instellen +Om GroupDocs.Search in je project te gebruiken, volg je deze stappen: + +1. **Voeg de afhankelijkheid toe**: Zoals hierboven getoond, voeg je de benodigde Maven‑afhankelijkheid toe aan je project of download je direct vanaf de releases‑pagina. +2. **License Acquisition**: + - Voor een gratis proefperiode kun je de bibliotheek gebruiken zonder beperkingen op functies, maar met enkele gebruikslimieten. + - Verkrijg een tijdelijke licentie voor volledige functietoegang tijdens evaluatie door [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/) te bezoeken. + - Koop een volledige licentie als je besluit GroupDocs.Search in je productieomgeving te integreren. +3. **Basisinitialisatie en -instelling**: Initialiseert de configuratie met de `Configuration`‑klasse, stel het basispad voor documenten in en specificeer een poortnummer: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Implementatiegids +Laten we nu de implementatie van belangrijke functionaliteiten verkennen met GroupDocs.Search Java. + +### Functie: Zoeknetwerk Configureren +**Overzicht**: Het opzetten van een zoeknetwerk omvat het definiëren van je documentdirectory en het configureren ervan met een specifieke poort voor communicatie tussen knooppunten. + +#### Stap 1: Documentdirectories en Poort Definiëren +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Stap 2: Zoeknetwerk Configureren +Maak het configuratie‑object aan met behulp van de gedefinieerde paden: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Functie: Zoeknetwerk‑knooppunten Implementeren +**Overzicht**: Implementeer knooppunten om documentzoekopdrachten efficiënt over je netwerk af te handelen. + +#### Stap 1: Knooppunten Implementeren met Configuratie +Implementeer zoeknetwerk‑knooppunten en identificeer de master‑node voor gecentraliseerd beheer: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Functie: Abonneren op Netwerk‑knooppunt‑Evenementen +**Overzicht**: Houd je zoeknetwerk in de gaten door je te abonneren op evenementen die je informeren over belangrijke wijzigingen of acties. + +#### Stap 1: Abonneren op Master‑Node‑Evenementen +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Functie: Documenten Indexeren in Netwerk‑knooppunten +**Overzicht**: Voeg directories met documenten toe aan het indexeringsproces voor efficiënte zoekopdrachten. + +#### Stap 1: Documentdirectories Toevoegen aan het Indexeringsproces +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Functie: Tekstzoekopdracht in Netwerk‑knooppunten +**Overzicht**: Voer tekstzoekopdrachten uit over alle geïndexeerde documenten binnen je zoeknetwerk. + +#### Stap 1: Een Tekstzoekopdracht Uitvoeren +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Functie: Shards Optimaliseren +**Overzicht**: Verbeter de prestaties door shards te optimaliseren binnen de indexer van je zoeknetwerk‑node. + +#### Stap 1: Indexer‑Shards Optimaliseren +Optimaliseer shards om de zoek‑efficiëntie te verbeteren (dit is waar **hoe je shards optimaliseert** echt van belang is): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Praktische Toepassingen +GroupDocs.Search voor Java kan worden toegepast in diverse real‑world scenario's: + +1. **Enterprise Document Management**: Faciliteer documentophaling over grote bedrijfsdatabases. +2. **E‑commerce Platforms**: Verbeter productzoekfunctionaliteit met geoptimaliseerde indexering en query‑features. +3. **Legal Firms**: Beheer en haal zaakdossiers en documenten efficiënt op uit uitgebreide archieven. +4. **Library Systems**: Versnel het catalogiseringsproces door integratie met digitale bibliotheeksystemen voor snelle zoekopdrachten. +5. **Content Management Systems (CMS)**: Verbeter de vindbaarheid van content via geavanceerde zoekmogelijkheden. + +## Prestatieoverwegingen +Om optimale prestaties van je GroupDocs.Search‑implementatie te garanderen: +- Optimaliseer regelmatig shards om de responstijd van queries te verkorten. +- Houd het geheugenverbruik in de gaten en beheer dit, vooral in omgevingen met grote datasets. +- Volg Java‑best practices voor garbage collection en resource‑beheer om de systeemefficiëntie te behouden. + +## Conclusie +Door deze uitgebreide gids te volgen, heb je geleerd hoe je een zoeknetwerk opzet en optimaliseert met GroupDocs.Search voor Java. Met deze vaardigheden kun je nu efficiënte documentzoekopdrachten uitvoeren in diverse toepassingen, waardoor de prestaties van je project en de gebruikerservaring worden verbeterd. Om de mogelijkheden van GroupDocs.Search verder te verkennen, overweeg je integratie met andere systemen of het onderzoeken van extra functies die in hun documentatie beschikbaar zijn. + +## FAQ Sectie +1. **Wat is shard-optimalisatie?** + - Shard-optimalisatie verbetert de prestaties van het zoeknetwerk door data efficiënter binnen elke shard te organiseren. +2. **Hoe ga ik om met poortconflicten bij het configureren van een zoeknetwerk?** + - Verander de basePort‑variabele naar een ongebruikte poort op je systeem en herstart het configuratieproces. +3. **Kan GroupDocs.Search worden geïntegreerd met bestaande Java‑applicaties?** + - Ja, het kan naadloos worden geïntegreerd door de bibliotheek‑afhankelijkheid in je project op te nemen. +4. **Wat zijn enkele veelvoorkomende problemen tijdens de installatie?** + - Veelvoorkomende problemen zijn onjuiste poortconfiguraties en ontbrekende afhankelijkheden; zorg ervoor dat je de voorvereisten nauwkeurig volgt. + +## Veelgestelde Vragen + +**Q: Hoe beïnvloedt shard-optimalisatie de snelheid van queries?** +A: Het optimaliseren van shards compacteert de index, vermindert schijf‑I/O en levert doorgaans snellere query‑reacties op. + +**Q: Is het veilig om `optimizeShards` uit te voeren op een live node?** +A: Ja, de bewerking is ontworpen om zonder downtime te draaien, maar het is het beste om dit te plannen tijdens perioden met weinig verkeer voor grote indexen. + +**Q: Kan ik de `OptimizeOptions` aanpassen?** +A: Absoluut. Je kunt parameters zoals `maxSegmentSize` of `mergeFactor` instellen om het optimalisatieproces fijn af te stemmen. + +**Q: Wat moet ik doen als ik een `IOException` tegenkom tijdens optimalisatie?** +A: Controleer de bestandsysteem‑rechten, zorg voor voldoende schijfruimte en bevestig dat geen ander proces de indexbestanden vergrendelt. + +**Q: Herstelt het optimaliseren van shards ook de ruimte van verwijderde documenten?** +A: Ja, de optimizer voegt segmenten samen en verwijdert tombstones, waardoor de door verwijderde documenten ingenomen ruimte vrijkomt. + +--- + +**Last Updated:** 2026-01-21 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs \ No newline at end of file diff --git a/content/english/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/english/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md index b6fa9ccf..20805bf2 100644 --- a/content/english/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md +++ b/content/english/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -1,7 +1,7 @@ --- -title: "Master GroupDocs.Search Java: Optimize Index & Query Performance" -description: "Learn how to efficiently create, configure, and optimize document indexes with GroupDocs.Search Java for enhanced search performance." -date: "2025-05-20" +title: "Improve Query Performance with GroupDocs.Search Java: Optimize Index & Search" +description: "Learn how to improve query performance and add documents to index while correctly escaping special characters query using GroupDocs.Search Java." +date: "2026-01-21" weight: 1 url: "/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/" keywords: @@ -10,28 +10,33 @@ keywords: - search query performance type: docs --- -# Master GroupDocs.Search Java: Optimize Index & Query Performance -## Introduction +# Improve Query Performance with GroupDocs.Search Java: Optimize Index & Search -Efficiently manage vast volumes of documents using powerful search capabilities. This guide helps you master creating and configuring an index with GroupDocs.Search Java, a robust tool for document indexing and searching. +Efficiently managing a massive collection of documents starts with **improving query performance**. In this tutorial you’ll discover how to create and configure a high‑performance index, **add documents to index**, and correctly **escape special characters query** so searches run fast and return accurate results. Whether you’re building a corporate knowledge base or a searchable e‑commerce catalog, mastering these steps will keep your application responsive under heavy load. -We will focus on key features such as setting up an index, adding documents, preparing search queries, and executing searches efficiently. Whether managing digital archives or building sophisticated information retrieval systems, understanding these processes is crucial. +## Quick Answers +- **What is the main goal?** Improve query performance by fine‑tuning the index and query handling. +- **Which library is used?** GroupDocs.Search for Java. +- **Do I need a license?** A free trial or temporary license is sufficient for development; a full license is required for production. +- **How do I add documents?** Use `index.add("YOUR_DOCUMENT_DIRECTORY")` to bulk‑load files. +- **How are special characters handled?** Configure the alphabet dictionary and escape characters like `()":&|!^~*?` before executing the search. -**What You'll Learn:** -- How to create and configure a document index using GroupDocs.Search Java. -- Techniques for indexing documents and optimizing search queries. -- Practical applications of GroupDocs.Search in real-world scenarios. -- Tips for enhancing performance during searches. +## What is “improve query performance”? +Improving query performance means reducing the time it takes for a search request to travel through the index, match terms, and return results. By configuring the index correctly and preparing queries that align with that configuration, you eliminate unnecessary processing and achieve faster response times. -Let's review the prerequisites you need before getting started! +## Why use GroupDocs.Search Java for high‑performance searches? +- **Scalable indexing** – Handles millions of documents with incremental updates. +- **Rich language support** – Built‑in analyzers for many alphabets and special characters. +- **Easy integration** – Works with any Java‑based application, from Spring Boot services to desktop tools. ## Prerequisites -Before we begin, ensure your development environment is ready to handle GroupDocs.Search Java. Here’s what you’ll need: +Before we dive in, make sure you have the following ready: ### Required Libraries and Dependencies To use GroupDocs.Search in a Maven project, include the following configurations: + ```xml @@ -51,27 +56,29 @@ To use GroupDocs.Search in a Maven project, include the following configurations ``` ### Environment Setup -- Ensure you have Java Development Kit (JDK) installed and properly configured. -- Use an IDE like IntelliJ IDEA or Eclipse for development. +- JDK 8 or newer installed and configured. +- IDE such as IntelliJ IDEA or Eclipse. ### Knowledge Prerequisites -Familiarity with: -- Java programming basics. -- Maven build tool concepts. -- Document management and search systems. +- Basic Java programming. +- Familiarity with Maven. +- Understanding of document management concepts. ## Setting Up GroupDocs.Search for Java -Integrate the GroupDocs.Search library into your Java project by following these steps: -1. **Install via Maven**: Use the provided XML snippet to add GroupDocs.Search to your `pom.xml` file. -2. **Direct Download Option**: If you prefer not using Maven, download the latest version from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). +### 1. Install via Maven or Direct Download +Add the XML snippet above to your `pom.xml`. If you prefer a manual approach, download the library from the official site: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### 2. Acquire a License +You can obtain a free trial or a temporary license here: -### License Acquisition -- Obtain a free trial license or request a temporary license by visiting [GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license). -- Consider purchasing if you need extended features and support. +[GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license) + +### 3. Basic Initialization +Create an `Index` object that points to a folder where the index files will be stored: -### Basic Initialization -To initialize GroupDocs.Search, create an `Index` object pointing to your target directory. Here’s how: ```java import com.groupdocs.search.*; @@ -86,35 +93,32 @@ public class SearchInitialization { ## Implementation Guide ### Creating and Configuring an Index -**Overview**: Setting up a document index involves defining specific character types within the alphabet dictionary, crucial for accurate search operations. +Configuring the alphabet dictionary lets you decide how special characters are treated, which is essential for **improve query performance**. #### Step 1: Initialize Index ```java Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); ``` -- **Parameter**: Directory path where indexed data will be stored. -- **Purpose**: Create an empty index that can later hold document information. #### Step 2: Configure Character Types -Modify the alphabet dictionary to handle special characters: ```java index.getDictionaries().getAlphabet() .setRange(new char[] {'&'}, CharacterType.Letter) .setRange(new char[] {'-'}, CharacterType.Separator); ``` -- **Explanation**: Treat '&' as a letter and '-' as a separator for search accuracy. +Treating `&` as a letter and `-` as a separator ensures the search engine parses queries the way you expect. ### Indexing Documents -**Overview**: Add documents to the index, enabling efficient search operations. +Now let’s **add documents to index** so they become searchable. #### Step 3: Adding Documents ```java index.add("YOUR_DOCUMENT_DIRECTORY"); ``` -- **Functionality**: Scans specified directory and adds all found documents into the index. - -### Preparing Search Query -**Overview**: Prepare your search query by modifying special characters to match configured dictionary settings. +The method scans the specified folder recursively and indexes every supported file type. + +### Preparing the Search Query +To **escape special characters query**, we first normalize the input based on the alphabet configuration, then add escape sequences. #### Step 4: Modify Special Characters ```java @@ -132,10 +136,8 @@ for (int i = 0; i < word.length(); i++) { } } ``` -- **Purpose**: Adjust search terms based on the alphabet configuration. #### Step 5: Escape Special Characters -Ensure special characters are escaped to avoid errors: ```java String specialCharacters = "()\":&|!^~*?"; for (int i = result.length() - 1; i >= 0; i--) { @@ -149,10 +151,10 @@ if (query.contains(" ")) { query = "\"" + query + "\""; } ``` -- **Explanation**: Escaping characters prevents misinterpretation during searches. +Escaping prevents the parser from misinterpreting symbols as operators. ### Executing the Search -**Overview**: Perform a search operation using the prepared query and retrieve results for further processing. +Finally, run the query against the prepared index. #### Step 6: Execute Search ```java @@ -160,48 +162,56 @@ import com.groupdocs.search.results.*; SearchResult searchResult = index.search(query); ``` -- **Functionality**: Use the `search` method to execute queries against indexed documents, returning matched results. +The `search` method returns a `SearchResult` object containing matched documents, snippets, and relevance scores. ## Practical Applications ### Case Study 1: Document Management Systems -Implement GroupDocs.Search for efficient document retrieval within corporate intranets or digital archives. For example, a law firm could quickly access case files tagged with specific legal terms. +Law firms can quickly locate case files by indexing PDFs, Word documents, and emails. By **improving query performance**, attorneys spend less time waiting for results and more time reviewing content. -### Case Study 2: E-commerce Platforms -Optimize product searches by indexing descriptions and tags to enhance customer experience on platforms like Amazon or eBay. +### Case Study 2: E‑commerce Platforms +Online retailers index product descriptions, specifications, and reviews. Properly escaped queries allow customers to search for phrases like `4‑K TV` without errors, while fast query execution keeps the shopping experience smooth. -## Performance Considerations +## Performance Considerations & Tips -**Tips for Optimization**: -- Regularly update the index after adding new documents. -- Use appropriate hardware resources to handle large datasets efficiently. -- Follow Java memory management best practices, such as using efficient data structures and minimizing object creation during searches. +- **Refresh the index** after bulk imports or large updates to keep search latency low. +- **Allocate sufficient heap memory** (`-Xmx2g` or higher) for large data sets. +- **Reuse the `Index` instance** across multiple searches instead of recreating it each time. +- **Profile query execution** using Java’s built‑in tools to identify bottlenecks. -## Conclusion +## Common Pitfalls & Solutions -This guide has equipped you with the knowledge to implement GroupDocs.Search Java effectively. By understanding how to create, configure, and utilize an index, along with preparing optimized search queries, you can enhance document search capabilities in your applications. +| Issue | Why it Happens | Fix | +|-------|----------------|-----| +| Queries return no results after adding new files | Index not updated | Call `index.add(newPath)` or rebuild the index. | +| Errors about unexpected characters | Special characters not escaped | Ensure the escape logic from Step 5 runs before searching. | +| High memory usage | Large result sets loaded at once | Iterate over `searchResult.getDocuments()` lazily or limit results with `index.search(query, 100)`. | -**Next Steps:** -- Experiment with different configurations and settings. -- Explore integration opportunities with other systems or tools for advanced use cases. +## Frequently Asked Questions -## FAQ Section +**Q: How do I handle extremely large datasets with GroupDocs.Search?** +A: Use incremental indexing (`index.add`) and schedule periodic index optimizations. Deploy the index on SSD storage for faster I/O. -1. **How do I handle large datasets with GroupDocs.Search?** - - Use efficient indexing strategies and ensure adequate hardware resources are available. +**Q: Can GroupDocs.Search be integrated with Spring Boot?** +A: Yes. Define the `Index` bean in a `@Configuration` class and inject it wherever you need search capabilities. -2. **Can GroupDocs.Search be integrated with other Java frameworks?** - - Yes, it can seamlessly integrate with Spring Boot or any Java-based web application framework. +**Q: Which characters must be escaped in a query?** +A: The characters `()":&|!^~*?` need a preceding backslash (`\`) to be treated as literals. -3. **What special characters need to be escaped in a search query?** - - Characters such as `()":&|!^~*?` should be properly escaped. +**Q: How can I update an existing index with newly uploaded documents?** +A: Call `index.add("NEW_DOCUMENT_DIRECTORY")`; the library will merge new entries without rebuilding the whole index. -4. **How do I update an existing index with new documents?** - - Use the `index.add(directoryPath)` method to add new files to the index. - -5. **Is GroupDocs.Search suitable for real-time applications?** - - Yes, it supports efficient indexing and searching, making it ideal for real-time search scenarios. +**Q: Is GroupDocs.Search suitable for real‑time search scenarios?** +A: Absolutely. The library supports fast incremental updates and low‑latency queries, making it ideal for live search boxes. ## Resources - [Documentation](https://docs.groupdocs.com/search/java/) - [API Reference](https://reference.groupdocs.com/) + +--- + +**Last Updated:** 2026-01-21 +**Tested With:** GroupDocs.Search Java 25.4 +**Author:** GroupDocs + +--- \ No newline at end of file diff --git a/content/english/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md b/content/english/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md index deb35257..69ec63aa 100644 --- a/content/english/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md +++ b/content/english/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md @@ -1,7 +1,7 @@ --- -title: "Java Search Network Configuration & Sync Guide with GroupDocs.Search" -description: "Learn to configure and synchronize a Java search network using GroupDocs.Search. Enhance document indexing and retrieval efficiently." -date: "2025-05-20" +title: "GroupDocs Maven Dependency – Java Search Network Sync" +description: "Learn how to add the GroupDocs Maven dependency, configure and synchronize a Java search network, and add directories to index with GroupDocs.Search." +date: "2026-01-21" weight: 1 url: "/java/search-network/java-groupdocs-search-configuration-sync-guide/" keywords: @@ -10,38 +10,31 @@ keywords: - Document Indexing and Retrieval type: docs --- -# Comprehensive Guide: Configuring and Synchronizing Java Search Networks with GroupDocs.Search -## Introduction +# GroupDocs Maven Dependency: Configuring and Synchronizing Java Search Networks -In today's data-driven world, managing and searching large volumes of documents is crucial for productivity and decision-making in organizations such as legal firms, financial institutions, and research bodies. This guide provides a detailed walkthrough on setting up a robust search network using GroupDocs.Search for Java—a powerful library that simplifies document indexing and retrieval. +In this comprehensive guide you’ll discover **how to add the GroupDocs Maven dependency** to your project and then configure a robust Java search network using GroupDocs.Search. Whether you’re handling legal briefs, financial reports, or academic papers, the steps below will help you index, search, and keep your shards in sync efficiently. -**What You'll Learn:** -- Configuring a search network with the GroupDocs.Search library -- Deploying nodes in your search network -- Subscribing to node events and managing them effectively -- Indexing documents into your search network -- Synchronizing shards across your network for optimal performance -- Properly closing network nodes after operations +## Introduction -By following this guide, you'll gain practical experience leveraging GroupDocs.Search Java to build a scalable and efficient search solution. +Managing and searching massive document collections is a daily challenge for many organizations. By integrating the **GroupDocs Maven dependency**, you gain access to a powerful indexing engine that scales across multiple nodes. This tutorial walks you through setting up the dependency, deploying network nodes, adding directories to index, and synchronizing shards for optimal performance. -### Prerequisites +### Quick Answers +- **What is the GroupDocs Maven dependency?** A Maven artifact that brings the GroupDocs.Search library into your Java project. +- **Why use a search network?** It distributes indexing and query load across multiple nodes, improving speed and reliability. +- **How do I add directories to index?** Use `IndexingDocuments.addDirectories` on the master node. +- **How to sync shards?** Call `SynchronizeOptions` on each node’s `Indexer`. +- **Do I need a license?** Yes, a trial or commercial license is required for production use. -Before configuring a search network with GroupDocs.Search for Java, ensure the following: -- **Required Libraries**: Use version 25.4 of GroupDocs.Search in your project. -- **Environment Setup Requirements**: - - Install the Java Development Kit (JDK) on your system - - Use an IDE like IntelliJ IDEA or Eclipse for development -- **Knowledge Prerequisites**: Basic understanding of Java programming, Maven configuration, and concepts of network nodes and document indexing. +## What is the GroupDocs Maven Dependency? -## Setting Up GroupDocs.Search for Java +The GroupDocs Maven dependency (`com.groupdocs:groupdocs-search`) packages all the classes you need to build searchable indexes, manage network nodes, and perform fast queries. Adding it to your `pom.xml` ensures Maven pulls the correct binaries and transitive dependencies. -To begin using GroupDocs.Search in your Java projects: +## How to Add the GroupDocs Maven Dependency ### Maven Configuration -Add the following to your `pom.xml` file to include GroupDocs.Search as a dependency: +Add the repository and dependency to your `pom.xml`: ```xml @@ -61,20 +54,20 @@ Add the following to your `pom.xml` file to include GroupDocs.Search as a depend ``` -### Direct Download +> **Pro tip:** Keep the version number up‑to‑date by checking the official releases page. -Alternatively, download the latest version directly from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). +You can also download the JAR directly from the official site: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). -### License Acquisition +## Prerequisites -To start with GroupDocs.Search: -- **Free Trial**: Sign up on the GroupDocs website. -- **Temporary License**: Apply for a temporary license to evaluate full capabilities without limitations. -- **Purchase**: Purchase a commercial license when ready for production use. +- **JDK** (11 or newer) installed. +- An IDE such as IntelliJ IDEA or Eclipse. +- Basic Java knowledge, Maven familiarity, and a grasp of network node concepts. +- A valid GroupDocs.Search license (free trial or commercial). -### Basic Initialization and Setup +## Basic Initialization and Setup -Initialize your project with these steps: +Start by creating an index directory: ```java import com.groupdocs.search.SearchIndex; @@ -84,17 +77,15 @@ import com.groupdocs.search.options.IndexingOptions; SearchIndex index = new SearchIndex("YOUR_INDEX_DIRECTORY"); ``` -This setup prepares you for configuring and deploying a search network. +This simple step prepares the environment for the subsequent network configuration. ## Implementation Guide -With your environment ready, proceed with implementing GroupDocs.Search features: - ### Feature 1: Configuration of Search Network #### Overview -Configuring the search network involves setting paths and ports necessary for node communication. This forms the backbone of your search architecture. +Configuring the search network sets the file paths and ports that nodes will use to communicate. ##### Set Up Paths and Ports ```java @@ -139,11 +130,11 @@ import com.groupdocs.search.scaling.SearchNetworkNodeEvents; SearchNetworkNodeEvents.subscribe(masterNode); ``` -### Feature 4: Indexing Documents into Search Network Node +### Feature 4: Adding Directories to Index #### Overview -Adding documents is critical for enabling search functionality. +Adding directories is the core step that makes your documents searchable. ##### Document Addition ```java @@ -178,7 +169,7 @@ def synchronizeShards(SearchNetworkNode node) { #### Overview -Properly closing nodes ensures all resources are released correctly. +Properly closing nodes releases resources and prevents memory leaks. ##### Node Closure ```java @@ -191,24 +182,49 @@ for (SearchNetworkNode node : nodes) { ## Practical Applications -1. **Legal Document Management**: Streamline the retrieval of case files. -2. **Financial Record Keeping**: Access financial statements quickly for audits or reviews. -3. **Academic Research**: Facilitate literature searches across large datasets, enhancing research productivity. +1. **Legal Document Management** – Quickly retrieve case files and precedents. +2. **Financial Record Keeping** – Access statements and audit trails in seconds. +3. **Academic Research** – Search across thousands of papers to find relevant citations. ## Performance Considerations -- **Optimize Queries**: Structure queries efficiently to reduce response time. -- **Memory Management**: Monitor and manage Java memory usage to avoid bottlenecks. -- **Scaling Strategy**: Strategically distribute nodes based on anticipated load and data volume. +- **Optimize Queries** – Write concise queries to reduce response time. +- **Memory Management** – Monitor JVM heap usage; consider GC tuning for large indexes. +- **Scaling Strategy** – Add nodes proportionally to data volume and query load. + +## Common Issues and Solutions + +| Issue | Cause | Solution | +|-------|-------|----------| +| Nodes fail to connect | Port conflict | Change `basePort` to an unused value | +| Index not updating | Event subscription missing | Ensure `SearchNetworkNodeEvents.subscribe(masterNode)` is called | +| High latency | Insufficient shards | Increase number of nodes and balance document distribution | + +## Frequently Asked Questions + +**Q: What is the primary benefit of using GroupDocs.Search?** +A: It provides fast, scalable search capabilities across large document sets with minimal configuration. + +**Q: Can I customize node configurations in a search network?** +A: Yes, you can set custom paths, ports, and other options via the `Configuration` object. + +**Q: How do I add directories to index after the network is running?** +A: Call `IndexingDocuments.addDirectories(masterNode, "path")` whenever you need to index new folders. + +**Q: How to sync shards when a new node joins the network?** +A: Use the `synchronizeShards` method shown above on the newly added node. + +**Q: Do I need a license for development?** +A: A free trial license is sufficient for testing; a commercial license is required for production. ## Conclusion -By following this guide, you've learned how to configure and deploy a search network using GroupDocs.Search for Java. This powerful library offers extensive functionalities that can be tailored to meet various document management needs. As next steps, consider exploring advanced features or integrating with other systems to further enhance your solution's capabilities. +By following this guide you now know how to **add the GroupDocs Maven dependency**, configure a multi‑node search network, index directories, and keep shards synchronized. These steps lay the foundation for a high‑performance document search solution that can grow with your organization’s needs. -## FAQ Section +--- -1. **What is the primary benefit of using GroupDocs.Search?** - - It provides fast and efficient search capabilities across large datasets. -2. **Can I customize node configurations in a search network?** - - Yes, you can set custom paths and ports to suit your environment requirements. +**Last Updated:** 2026-01-21 +**Tested With:** GroupDocs.Search 25.4 +**Author:** GroupDocs +--- \ No newline at end of file diff --git a/content/english/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/english/java/search-network/optimize-search-network-groupdocs-java/_index.md index a2f3f613..86b554bc 100644 --- a/content/english/java/search-network/optimize-search-network-groupdocs-java/_index.md +++ b/content/english/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -1,7 +1,7 @@ --- -title: "Optimize Your Search Network Using GroupDocs.Search for Java: A Comprehensive Guide" -description: "Learn how to configure and optimize your search network with GroupDocs.Search for Java. Streamline document retrieval with efficient indexing, text searches, and shard optimization." -date: "2025-05-20" +title: "How to Optimize Shards in GroupDocs.Search for Java: A Comprehensive Guide" +description: "Learn how to optimize shards using GroupDocs.Search for Java and how to configure search network, perform text search, and handle port conflicts." +date: "2026-01-21" weight: 1 url: "/java/search-network/optimize-search-network-groupdocs-java/" keywords: @@ -10,20 +10,29 @@ keywords: - document indexing type: docs --- -# Optimize Your Search Network Using GroupDocs.Search for Java: A Comprehensive Guide -## Introduction +# How to Optimize Shards in GroupDocs.Search for Java: A Comprehensive Guide -Efficient document searching is essential for developers and businesses managing large databases or looking to streamline internal document retrieval processes. **GroupDocs.Search Java** offers seamless configuration and optimization of your search network, enhancing both performance and user experience. +Efficient document searching is essential for developers and businesses managing large databases or looking to streamline internal document retrieval processes. If you're wondering **how to optimize shards**, this guide will walk you through the steps to improve performance, configure your search network, and handle common challenges such as port conflicts. **GroupDocs.Search Java** offers seamless configuration and optimization of your search network, enhancing both performance and user experience. -In this tutorial, we'll guide you through using GroupDocs.Search for Java to set up a robust search network with features like deploying nodes, subscribing to events, indexing documents, performing text searches, and optimizing shards. By the end, you will have mastered: -- Configuring a search network -- Deploying and managing search network nodes -- Indexing documents efficiently -- Performing optimized text searches -- Enhancing performance through shard optimization +## Quick Answers +- **What is shard optimization?** It reorganizes index data to speed up queries and reduce storage overhead. +- **How to configure a search network?** Define a base directory and port, then deploy nodes using the provided API. +- **How to perform text search?** Use `TextSearchInNetwork.searchAll` with your query string. +- **How to index documents in Java?** Add document directories to the master node with `IndexingDocuments.addDirectories`. +- **How to handle port conflicts?** Change the `basePort` variable to an unused port on your machine. -Let's explore how to leverage GroupDocs.Search for overcoming document search challenges. +## How to Configure Search Network +Before diving into indexing and searching, you need a solid network foundation. This section explains the steps to set up the network, choose a port, and avoid common port‑conflict issues. + +## How to Index Documents Java +Once the network is up, the next step is to feed it with content. We'll show you how to add multiple document folders so the engine can build a searchable index. + +## How to Perform Text Search +After indexing, you’ll want to retrieve information quickly. This part demonstrates the simplest way to run a text query across all nodes. + +## How to Handle Port Conflicts +If the default port (`49132`) is already in use, simply change the `basePort` value to a free port and restart the configuration. This prevents startup errors and keeps your network stable. ## Prerequisites Before we begin, ensure you have the following prerequisites in place: @@ -55,7 +64,7 @@ Alternatively, download the latest version from [GroupDocs.Search for Java relea - Access to a network configuration allowing port usage. ### Knowledge Prerequisites -A basic understanding of Java programming, including object-oriented principles and exception handling, will be beneficial for this tutorial. +A basic understanding of Java programming, including object‑oriented principles and exception handling, will be beneficial for this tutorial. ## Setting Up GroupDocs.Search for Java To begin using GroupDocs.Search in your project, follow these steps: @@ -136,7 +145,7 @@ TextSearchInNetwork.searchAll(masterNode, "ligula", false); **Overview**: Enhance performance by optimizing shards within the indexer of your search network node. #### Step 1: Optimize Indexer Shards -Optimize shards to improve search efficiency: +Optimize shards to improve search efficiency (this is where **how to optimize shards** really matters): ```java public static void optimizeShards(SearchNetworkNode node) { @@ -152,9 +161,9 @@ TextSearchInNetwork.searchAll(masterNode, "ligula", false); ``` ## Practical Applications -GroupDocs.Search for Java can be applied in various real-world scenarios: +GroupDocs.Search for Java can be applied in various real‑world scenarios: 1. **Enterprise Document Management**: Facilitate document retrieval across large corporate databases. -2. **E-commerce Platforms**: Enhance product search capabilities using optimized indexing and querying features. +2. **E‑commerce Platforms**: Enhance product search capabilities using optimized indexing and querying features. 3. **Legal Firms**: Efficiently manage and retrieve case files and documents from extensive archives. 4. **Library Systems**: Streamline the cataloging process by integrating with digital library systems for quick searches. 5. **Content Management Systems (CMS)**: Improve content discoverability through advanced search capabilities. @@ -177,3 +186,28 @@ By following this comprehensive guide, you've learned how to set up and optimize - Yes, it can be seamlessly integrated by including the library dependency in your project. 4. **What are some common issues faced during setup?** - Common issues include incorrect port configurations and missing dependencies; ensure you follow the prerequisites accurately. + +## Frequently Asked Questions + +**Q: How does shard optimization affect query speed?** +A: Optimizing shards compacts the index, reduces disk I/O, and typically yields faster query responses. + +**Q: Is it safe to run `optimizeShards` on a live node?** +A: Yes, the operation is designed to run without downtime, but it’s best to schedule during low‑traffic periods for large indexes. + +**Q: Can I customize the `OptimizeOptions`?** +A: Absolutely. You can set parameters such as `maxSegmentSize` or `mergeFactor` to fine‑tune the optimization process. + +**Q: What should I do if I encounter an `IOException` during optimization?** +A: Verify file system permissions, ensure enough disk space, and confirm that no other process is locking the index files. + +**Q: Does optimizing shards also reclaim deleted document space?** +A: Yes, the optimizer merges segments and removes tombstones, freeing up space occupied by deleted documents. + +--- + +**Last Updated:** 2026-01-21 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs + +--- \ No newline at end of file diff --git a/content/french/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/french/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md new file mode 100644 index 00000000..a7282c00 --- /dev/null +++ b/content/french/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -0,0 +1,217 @@ +--- +date: '2026-01-21' +description: Apprenez comment améliorer les performances des requêtes et ajouter des + documents à l’index tout en échappant correctement les caractères spéciaux dans + la requête en utilisant GroupDocs.Search Java. +keywords: +- GroupDocs.Search Java +- document index optimization +- search query performance +title: 'Améliorer les performances des requêtes avec GroupDocs.Search Java : optimiser + l’index et la recherche' +type: docs +url: /fr/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/ +weight: 1 +--- + +# Améliorer les performances des requêtes avec GroupDocs.Search Java : optimiser l'index et la recherche + +Gérer efficacement une collection massive de documents commence par **améliorer les performances des requêtes**. Dans ce tutoriel, vous découvrirez comment créer et configurer un index haute performance, **ajouter des documents à l'index**, et correctement **échapper les caractères spéciaux dans la requête** afin que les recherches soient rapides et renvoient des résultats précis. Que vous construisiez une base de connaissances d'entreprise ou un catalogue e‑commerce consultable, maîtriser ces étapes permettra à votre application de rester réactive sous une charge importante. + +## Réponses rapides +- **Quel est l'objectif principal ?** Améliorer les performances des requêtes en ajustant finement l'index et la gestion des requêtes. +- **Quelle bibliothèque est utilisée ?** GroupDocs.Search pour Java. +- **Ai‑je besoin d’une licence ?** Un essai gratuit ou une licence temporaire suffit pour le développement ; une licence complète est requise pour la production. +- **Comment ajouter des documents ?** Utilisez `index.add("YOUR_DOCUMENT_DIRECTORY")` pour charger les fichiers en masse. +- **Comment les caractères spéciaux sont‑ils gérés ?** Configurez le dictionnaire d'alphabet et échappez les caractères comme `()":&|!^~*?` avant d'exécuter la recherche. + +## Qu’est‑ce que « améliorer les performances des requêtes » ? +Améliorer les performances des requêtes signifie réduire le temps nécessaire à une requête de recherche pour traverser l'index, faire correspondre les termes et renvoyer les résultats. En configurant correctement l'index et en préparant des requêtes qui correspondent à cette configuration, vous éliminez les traitements inutiles et obtenez des temps de réponse plus rapides. + +## Pourquoi utiliser GroupDocs.Search Java pour des recherches haute performance ? +- **Indexation évolutive** – Gère des millions de documents avec des mises à jour incrémentielles. +- **Support linguistique riche** – Analyseurs intégrés pour de nombreux alphabets et caractères spéciaux. +- **Intégration facile** – Fonctionne avec toute application Java, des services Spring Boot aux outils de bureau. + +## Prérequis + +Avant de commencer, assurez‑vous d’avoir les éléments suivants prêts : + +### Bibliothèques et dépendances requises +Pour utiliser GroupDocs.Search dans un projet Maven, incluez les configurations suivantes : + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Configuration de l’environnement +- JDK 8 ou version ultérieure installé et configuré. +- IDE tel qu’IntelliJ IDEA ou Eclipse. + +### Prérequis de connaissances +- Programmation Java de base. +- Familiarité avec Maven. +- Compréhension des concepts de gestion de documents. + +## Configuration de GroupDocs.Search pour Java + +### 1. Installation via Maven ou téléchargement direct +Ajoutez le fragment XML ci‑dessus à votre `pom.xml`. Si vous préférez une approche manuelle, téléchargez la bibliothèque depuis le site officiel : + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### 2. Obtention d’une licence +Vous pouvez obtenir un essai gratuit ou une licence temporaire ici : + +[GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license) + +### 3. Initialisation de base +Créez un objet `Index` qui pointe vers un dossier où les fichiers d’index seront stockés : + +```java +import com.groupdocs.search.*; + +public class SearchInitialization { + public static void main(String[] args) { + Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); + System.out.println("GroupDocs.Search initialized successfully."); + } +} +``` + +## Guide d’implémentation + +### Création et configuration d’un index +Configurer le dictionnaire d’alphabet vous permet de décider comment les caractères spéciaux sont traités, ce qui est essentiel pour **améliorer les performances des requêtes**. + +#### Étape 1 : Initialiser l’index +```java +Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); +``` + +#### Étape 2 : Configurer les types de caractères +```java +index.getDictionaries().getAlphabet() + .setRange(new char[] {'&'}, CharacterType.Letter) + .setRange(new char[] {'-'}, CharacterType.Separator); +``` +Traiter `&` comme une lettre et `-` comme un séparateur garantit que le moteur de recherche analyse les requêtes comme vous le souhaitez. + +### Indexation des documents +Maintenant, **ajoutons des documents à l’index** afin qu’ils soient recherchables. + +#### Étape 3 : Ajouter des documents +```java +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` +La méthode parcourt le dossier spécifié de manière récursive et indexe chaque type de fichier pris en charge. + +### Préparation de la requête de recherche +Pour **échapper les caractères spéciaux dans la requête**, nous normalisons d’abord l’entrée en fonction de la configuration de l’alphabet, puis ajoutons les séquences d’échappement. + +#### Étape 4 : Modifier les caractères spéciaux +```java +StringBuilder result = new StringBuilder(); +String word = "rock&roll-music"; + +for (int i = 0; i < word.length(); i++) { + char character = word.charAt(i); + CharacterType characterType = index.getDictionaries().getAlphabet().getCharacterType(character); + + if (characterType == CharacterType.Separator) { + result.append(' '); + } else { + result.append(character); + } +} +``` + +#### Étape 5 : Échapper les caractères spéciaux +```java +String specialCharacters = "()\":&|!^~*?"; +for (int i = result.length() - 1; i >= 0; i--) { + char c = result.charAt(i); + if (specialCharacters.indexOf(c) != -1) { + result.insert(i, '\\'); + } +} +String query = result.toString(); +if (query.contains(" ")) { + query = "\"" + query + "\""; +} +``` +L’échappement empêche le parseur d’interpréter à tort les symboles comme des opérateurs. + +### Exécution de la recherche +Enfin, exécutez la requête sur l’index préparé. + +#### Étape 6 : Exécuter la recherche +```java +import com.groupdocs.search.results.*; + +SearchResult searchResult = index.search(query); +``` + +## Applications pratiques + +### Étude de cas 1 : systèmes de gestion de documents +Les cabinets d’avocats peuvent localiser rapidement les dossiers en indexant les PDF, documents Word et e‑mails. En **améliorant les performances des requêtes**, les avocats passent moins de temps à attendre les résultats et plus de temps à examiner le contenu. + +### Étude de cas 2 : plateformes e‑commerce +Les détaillants en ligne indexent les descriptions de produits, les spécifications et les avis. Des requêtes correctement échappées permettent aux clients de rechercher des expressions comme `4‑K TV` sans erreurs, tandis qu’une exécution rapide des requêtes assure une expérience d’achat fluide. + +## Considérations de performance et conseils + +- **Actualisez l’index** après des importations massives ou de grandes mises à jour afin de maintenir une latence de recherche faible. +- **Allouez suffisamment de mémoire heap** (`-Xmx2g` ou plus) pour les grands ensembles de données. +- **Réutilisez l’instance `Index`** pour plusieurs recherches au lieu de la recréer à chaque fois. +- **Profiliez l’exécution des requêtes** à l’aide des outils intégrés de Java pour identifier les goulets d’étranglement. + +## Pièges courants et solutions + +| Problème | Pourquoi cela se produit | Solution | +|----------|--------------------------|----------| +| Les requêtes ne renvoient aucun résultat après l’ajout de nouveaux fichiers | Index non mis à jour | Appelez `index.add(newPath)` ou reconstruisez l’index. | +| Erreurs concernant des caractères inattendus | Caractères spéciaux non échappés | Assurez‑vous que la logique d’échappement de l’Étape 5 s’exécute avant la recherche. | +| Utilisation élevée de mémoire | Jeux de résultats volumineux chargés en une fois | Parcourez `searchResult.getDocuments()` de manière paresseuse ou limitez les résultats avec `index.search(query, 100)`. | + +## Questions fréquentes + +**Q : Comment gérer des ensembles de données extrêmement volumineux avec GroupDocs.Search ?** +R : Utilisez l’indexation incrémentielle (`index.add`) et planifiez des optimisations périodiques de l’index. Déployez l’index sur un stockage SSD pour des entrées‑sorties plus rapides. + +**Q : GroupDocs.Search peut‑il être intégré à Spring Boot ?** +R : Oui. Définissez le bean `Index` dans une classe `@Configuration` et inject dans une requête ?** +R : Les caractères `()":&|!^~*?` nécessitent un antislash (`\`) précédant pour être traités comme des littéraux. + +**Q : Comment mettre à jour un index existant avec des documents nouvellement téléchargés ?** +R : Appelez `index.add("NEW_DOCUMENT_DIRECTORY")` ; la bibliothèque fusionnera les nouvelles entrées sans reconstruire l’ensemble de l’index. + +**Q : GroupDocs.Search est‑il adapté aux scénarios de recherche en temps réel ?** +R : Absolument. La bibliothèque prend en charge des mises à jour incrémentielles rapides et des requêtes à faible latence, ce qui la rend idéale pour les boîtes de recherche en direct. + +## Ressources +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/) + +--- + +**Dernière mise à jour :** 2026-01-21 +**Testé avec :** GroupDocs.Search Java 25.4 +**Auteur :** GroupDocs + +--- \ No newline at end of file diff --git a/content/french/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/french/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..c39c64d6 --- /dev/null +++ b/content/french/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,211 @@ +--- +date: '2026-01-21' +description: Apprenez à optimiser les shards avec GroupDocs.Search pour Java, à configurer + le réseau de recherche, à effectuer une recherche de texte et à gérer les conflits + de ports. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Comment optimiser les shards dans GroupDocs.Search pour Java : guide complet' +type: docs +url: /fr/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# Comment optimiser les shards dans GroupDocs.Search pour Java : Guide complet + +La recherche efficace de documents est essentielle pour les développeurs et les entreprises qui gèrent de grandes bases de données ou qui souhaitent rationaliser les processus de récupération interne des documents. Si vous vous demandez **comment optimiser les shards**, ce guide vous accompagnera à travers les étapes pour améliorer les performances, configurer votre réseau de recherche et gérer les défis courants tels que les conflits de ports. **GroupDocs.Search Java** offre une configuration et une optimisation fluides de votre réseau de recherche, améliorant à la fois les performances et l'expérience utilisateur. + +## Réponses rapides +- **Qu'est-ce que l'optimisation des shards ?** Elle réorganise les données d'index pour accélérer les requêtes et réduire la surcharge de stockage. +- **Comment configurer un réseau de recherche ?** Définissez un répertoire de base et un port, puis déployez les nœuds à l'aide de l'API fournie. +- **Comment effectuer une recherche textuelle ?** Utilisez `TextSearchInNetwork.searchAll` avec votre chaîne de requête. +- **Comment indexer des documents en Java ?** Ajoutez les répertoires de documents au nœud maître avec `IndexingDocuments.addDirectories`. +- **Comment gérer les conflits de ports ?** Changez la variable `basePort` vers un port inutilisé sur votre machine. + +## Comment configurer le réseau de recherche +Avant de plonger dans l'indexation et la recherche, vous avez besoin d'une base réseau solide. Cette section explique les étapes pour mettre en place le réseau, choisir un port et éviter les problèmes courants de conflit de ports. + +## Comment indexer des documents en Java +Une fois le réseau opérationnel, l'étape suivante consiste à le nourrir en contenu. Nous vous montrerons comment ajouter plusieurs dossiers de documents afin que le moteur puisse construire un index searchable. + +## Comment effectuer une recherche textuelle +Après l'indexation, vous voudrez récupérer les informations rapidement. Cette partie démontre la façon la plus simple d'exécuter une requête textuelle sur tous les nœuds. + +## Comment gérer les conflits de ports +Si le port par défaut (`49132`) est déjà utilisé, il suffit de changer la valeur `basePort` vers un port libre et de redémarrer la configuration. Cela empêche les erreurs de démarrage et maintient votre réseau stable. + +## Prérequis +Avant de commencer, assurez-vous que les prérequis suivants sont en place : + +### Bibliothèques requises, versions et dépendances +Pour implémenter cette solution, incluez la bibliothèque GroupDocs.Search en utilisant Maven en ajoutant la configuration suivante à votre fichier `pom.xml` : + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` +Alternativement, téléchargez la dernière version depuis [GroupDocs.Search pour Java - releases](https://releases.groupdocs.com/search/java/). + +### Exigences de configuration de l'environnement +- Assurez-vous que votre environnement de développement prend en charge Java (JDK 8 ou supérieur). +- Accès à une configuration réseau permettant l'utilisation de ports. + +### Prérequis de connaissances +Une compréhension de base de la programmation Java, y compris les principes orientés objet et la gestion des exceptions, sera bénéfique pour ce tutoriel. + +## Configuration de GroupDocs.Search pour Java +Pour commencer à utiliser GroupDocs.Search dans votre projet, suivez ces étapes : + +1. **Ajouter la dépendance** : Comme indiqué ci‑dessus, ajoutez la dépendance Maven nécessaire à votre projet ou téléchargez‑la directement depuis la page des releases. +2. **Acquisition de licence** : + - Pour un essai gratuit, utilisez la bibliothèque sans restrictions de fonctionnalités mais avec certaines limitations d'utilisation. + - Obtenez une licence temporaire pour un accès complet aux fonctionnalités pendant l'évaluation en visitant [Licence temporaire GroupDocs](https://purchase.groupdocs.com/temporary-license/). + - Achetez une licence complète si vous décidez d'intégrer GroupDocs.Search dans votre environnement de production. +3. **Initialisation et configuration de base** : + Initialise la configuration à l'aide de la classe `Configuration`, en définissant le chemin de base pour les documents et en spécifiant un numéro de port : + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Guide d'implémentation +Explorons maintenant l'implémentation des fonctionnalités clés avec GroupDocs.Search Java. + +### Fonctionnalité : Configuration du réseau de recherche +**Vue d'ensemble** : Mettre en place un réseau de recherche implique de définir votre répertoire de documents et de le configurer avec un port spécifique pour la communication entre les nœuds. + +#### Étape 1 : Définir les répertoires de documents et le port +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Étape 2 : Configurer le réseau de recherche +Créez l'objet de configuration en utilisant les chemins définis : + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Fonctionnalité : Déploiement des nœuds du réseau de recherche +**Vue d'ensemble** : Déployez des nœuds pour gérer les recherches de documents efficacement à travers votre réseau. + +#### Étape 1 : Déployer les nœuds à l'aide de la configuration +Déployez les nœuds du réseau de recherche et identifiez le nœud maître pour la gestion centralisée : + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Fonctionnalité : Souscription aux événements des nœuds du réseau +**Vue d'ensemble** : Surveillez votre réseau de recherche en vous abonnant aux événements qui vous notifient des changements ou actions importants. + +#### Étape 1 : S'abonner aux événements du nœud maître +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Fonctionnalité : Indexation des documents dans les nœuds du réseau +**Vue d'ensemble** : Ajoutez des répertoires contenant des documents au processus d'indexation pour des recherches efficaces. + +#### Étape 1 : Ajouter les répertoires de documents au processus d'indexation +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Fonctionnalité : Recherche textuelle dans les nœuds du réseau +**Vue d'ensemble** : Exécutez des recherches textuelles sur tous les documents indexés au sein de votre réseau de recherche. + +#### Étape 1 : Effectuer une recherche textuelle +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Fonctionnalité : Optimisation des shards +**Vue d'ensemble** : Améliorez les performances en optimisant les shards au sein de l'indexeur de votre nœud du réseau de recherche. + +#### Étape 1 : Optimiser les shards de l'indexeur +Optimisez les shards pour améliorer l'efficacité des recherches (c’est ici que **comment optimiser les shards** prend tout son sens) : + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Applications pratiques +GroupDocs.Search pour Java peut être appliqué dans divers scénarios réels : +1. **Gestion documentaire d'entreprise** : Faciliter la récupération de documents dans de grandes bases de données corporatives. +2. **Plateformes e‑commerce** : Améliorer les capacités de recherche de produits grâce à une indexation et des requêtes optimisées. +3. **Cabinets juridiques** : Gérer et récupérer efficacement les dossiers et documents de cas à partir d'archives étendues. +4. **Systèmes de bibliothèques** : Rationaliser le processus de catalogage en s'intégrant aux systèmes de bibliothèques numériques pour des recherches rapides. +5. **Systèmes de gestion de contenu (CMS)** : Améliorer la découvrabilité du contenu grâce à des capacités de recherche avancées. + +## Considérations de performance +Pour garantir des performances optimales de votre implémentation GroupDocs.Search : +- Optimisez régulièrement les shards afin de réduire les temps de réponse des requêtes. +- Surveillez et gérez l'utilisation de la mémoire, surtout dans les environnements manipulant de grands ensembles de données. +- Suivez les meilleures pratiques Java pour le ramassage des ordures et la gestion des ressources afin de maintenir l'efficacité du système. + +## Conclusion +En suivant ce guide complet, vous avez appris à configurer et optimiser un réseau de recherche avec GroupDocs.Search pour Java. Avec ces compétences, vous êtes maintenant capable de gérer des recherches de documents efficaces dans diverses applications, améliorant les performances de votre projet et l'expérience utilisateur. Pour explorer davantage les capacités de GroupDocs.Search, envisagez de l'intégrer à d'autres systèmes ou d'explorer les fonctionnalités supplémentaires disponibles dans leur documentation. + +## Section FAQ +1. **Qu'est-ce que l'optimisation des shards ?** + - L'optimisation des shards améliore les performances du réseau de recherche en organisant les données de manière plus efficace au sein de chaque shard. +2. **Comment gérer les conflits de ports lors de la configuration d'un réseau de recherche ?** + - Changez la variable `basePort` vers un port inutilisé sur votre système et redémarrez le processus de configuration. +3. **GroupDocs.Search peut-il être intégré à des applications Java existantes ?** + - Oui, il peut être intégré de manière transparente en incluant la dépendance de la bibliothèque dans votre projet. +4. **Quels sont les problèmes courants rencontrés lors de l'installation ?** + - Les problèmes courants incluent des configurations de ports incorrectes et des dépendances manquantes ; assurez‑vous de suivre précisément les prérequis. + +## Questions fréquemment posées + +**Q : Comment l'optimisation des shards affecte‑t‑elle la vitesse des requêtes ?** +R : L'optimisation des shards compacte l'index, réduit les I/O disque et entraîne généralement des réponses aux requêtes plus rapides. + +**Q : Est‑il sûr d'exécuter `optimizeShards` sur un nœud en production ?** +R : Oui, l'opération est conçue pour s'exécuter sans interruption, mais il est préférable de la planifier pendant les périodes de faible trafic pour les gros index. + +**Q : Puis‑je personnaliser les `OptimizeOptions` ?** +R : Absolument. Vous pouvez définir des paramètres tels que `maxSegmentSize` ou `mergeFactor` pour affiner le processus d'optimisation. + +**Q : Que faire si je rencontre une `IOException` pendant l'optimisation ?** +R : Vérifiez les permissions du système de fichiers, assurez‑vous qu'il y a suffisamment d'espace disque et confirmez qu'aucun autre processus ne verrouille les fichiers d'index. + +**Q : L'optimisation des shards libère‑t‑elle également l'espace des documents supprimés ?** +R : Oui, l'optimiseur fusionne les segments et supprime les tombstones, libérant ainsi l'espace occupé par les documents supprimés. + +--- + +**Dernière mise à jour :** 2026-01-21 +**Testé avec :** GroupDocs.Search 25.4 pour Java +**Auteur :** GroupDocs \ No newline at end of file diff --git a/content/german/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/german/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md new file mode 100644 index 00000000..9a89436c --- /dev/null +++ b/content/german/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -0,0 +1,215 @@ +--- +date: '2026-01-21' +description: Erfahren Sie, wie Sie die Abfrageleistung verbessern und Dokumente zum + Index hinzufügen, während Sie Sonderzeichen in Abfragen korrekt escapen, mit GroupDocs.Search + Java. +keywords: +- GroupDocs.Search Java +- document index optimization +- search query performance +title: 'Verbessern Sie die Abfrageleistung mit GroupDocs.Search Java: Index und Suche + optimieren' +type: docs +url: /de/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/ +weight: 1 +--- + +# Verbesserte Abfrageleistung mit GroupDocs.Search Java: Index & Suche optimieren + +Effizientes Verwalten einer riesigen Dokumentensammlung beginnt mit **Verbesserung der Abfrageleistung**. In diesem Tutorial erfahren Sie, wie Sie einen Hochleistungs‑Index erstellen und konfigurieren, **Dokumente zum Index hinzufügen** und **Sonderzeichen in Abfragen escapen**, sodass Suchvorgänge schnell ausgeführt ob Sie ein Unternehmens‑Wissensdatenbank oder einen durchsuchbaren E‑Commerce‑- **Was ist das Hauptziel?** Verbesserung der Abfrageleistung durch Feinabstimmung des Index und der Abfrageverarbeitung. +- **Welche Bibliothek wird verwendet?** GroupDocs.Search für Java. +- **Benötige ich eine Lizenz?** Eine kostenlose Testversion oder temporäre Lizenz reicht für die Entwicklung aus; für die Produktion ist eine Voll‑Lizenz erforderlich. +- **Wie füge ich Dokumente hinzu?** Verwenden Sie `index.add("YOUR_DOCUMENT_DIRECTORY")`, um Dateien stapelweise zu laden. +- **Wie werden Sonderzeichen behandelt?** Konfigurieren Sie das Alphabet‑Wörterbuch und escapen Sie Zeichen wie `()\":&|!^~*?` bevor Sie die Suche ausführen. + +## Was bedeutet „Verbesserung der Abfrageleistung“? +Die Verbesserung der Abfrageleistung bedeutet, die Zeit zu verkürzen, die eine Suchanfrage benötigt, um den Index zu durchlaufen, Begriffe zu finden und Ergebnisse zurückzugeben. Durch die korrekte Konfiguration des Index und die Vorbereitung von Abfragen, die mit dieser Konfiguration übereinstimmen, eliminieren Sie unnötige Verarbeitung und erzielen schnellere Antwortzeiten. + +## Warum GroupDocs.Search Java für Hochleistungs‑Suche verwenden? +- **Skalierbare Indizierung** – Verarbeitet Millionen von Dokumenten mit inkrementellen Updates. +- **Umfangreiche Sprachunterstützung** – Eingebaute Analyzer für viele Alphabete und Sonderzeichen. +- **Einfache Integration** – Funktioniert mit jeder Java‑basierten Anwendung, von Spring‑Boot‑Services bis zu Desktop‑Tools. + +## Voraussetzungen + +Bevor wir beginnen, stellen Sie sicher, dass Sie Folgendes bereit haben: + +### Erforderliche Bibliotheken und Abhängigkeiten +Um GroupDocs.Search in einem Maven‑Projekt zu verwenden, fügen Sie die folgenden Konfigurationen ein: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Umgebung einrichten +- JDK 8 oder neuer installiert und konfiguriert. +- IDE wie IntelliJ IDEA oder Eclipse. + +### Wissensvoraussetzungen +- Grundlegende Java‑Programmierung. +- Vertrautheit mit Maven. +- Verständnis von Dokumenten‑Management‑Konzepten. + +## Einrichtung von GroupDocs.Search für Java + +### 1. Installation über Maven oder Direktdownload +Fügen Sie den obigen XML‑Snippet zu Ihrer `pom.xml` hinzu. Wenn Sie einen manuellen Ansatz bevorzugen, laden Sie die Bibliothek von der offiziellen Seite herunter: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### 2. Lizenz erwerben +Sie können hier eine kostenlose Testversion oder eine temporäre Lizenz erhalten: + +[GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license) + +### 3. Grundlegende Initialisierung +Erstellen Sie ein `Index`‑Objekt, das auf einen Ordner zeigt, in dem die Indexdateien gespeichert werden: + +```java +import com.groupdocs.search.*; + +public class SearchInitialization { + public static void main(String[] args) { + Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); + System.out.println("GroupDocs.Search initialized successfully."); + } +} +``` + +## Implementierungs‑Leitfaden + +### Erstellen und Konfigurieren eines Index +Die Konfiguration des Alphabet‑Wörterbuchs ermöglicht es Ihnen zu bestimmen, wie Sonderzeichen behandelt werden, was für die **Verbesserung der Abfrageleistung** entscheidend ist. + +#### Schritt 1: Index initialisieren +```java +Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); +``` + +#### Schritt 2: Zeichentypen konfigurieren +```java +index.getDictionaries().getAlphabet() + .setRange(new char[] {'&'}, CharacterType.Letter) + .setRange(new char[] {'-'}, CharacterType.Separator); +``` +Die Behandlung von `&` als Buchstabe und `-` als Trennzeichen stellt sicher, dass die Suchmaschine Abfragen so analysiert, wie Sie es erwarten. + +### Dokumente indizieren +Jetzt **Dokumente zum Index hinzufügen**, damit sie durchsuchbar werden. + +#### Schritt 3: Dokumente hinzufügen +```java +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` +Die Methode durchsucht den angegebenen Ordner rekursiv und indiziert jede unterstützte Dateityp. + +### Vorbereitung der Suchabfrage +Um **Sonderzeichen in Abfragen zu escapen**, normalisieren wir zunächst die Eingabe basierend auf der Alphabet‑Konfiguration und fügen dann Escape‑Sequenzen hinzu. + +#### Schritt 4: Sonderzeichen modifizieren +```java +StringBuilder result = new StringBuilder(); +String word = "rock&roll-music"; + +for (int i = 0; i < word.length(); i++) { + char character = word.charAt(i); + CharacterType characterType = index.getDictionaries().getAlphabet().getCharacterType(character); + + if (characterType == CharacterType.Separator) { + result.append(' '); + } else { + result.append(character); + } +} +``` + +#### Schritt 5: Sonderzeichen escapen +```java +String specialCharacters = "()\":&|!^~*?"; +for (int i = result.length() - 1; i >= 0; i--) { + char c = result.charAt(i); + if (specialCharacters.indexOf(c) != -1) { + result.insert(i, '\\'); + } +} +String query = result.toString(); +if (query.contains(" ")) { + query = "\"" + query + "\""; +} +``` +Escapen verhindert, dass der Parser Symbole als Operatoren missinterpretiert. + +### Ausführen der Suche +Führen Sie schließlich die Abfrage gegen den vorbereiteten Index aus. + +#### Schritt 6: Suche ausführen +```java +import com.groupdocs.search.results.*; + +SearchResult searchResult = index.search(query); +``` +Die Methode `search` gibt ein `SearchResult`‑Objekt zurück, das gefundene Dokumente, Ausschnitte und Relevanz‑Scores enthält. + +## Praktische Anwendungen + +### Fallstudie 1: Dokumenten‑Management‑Systeme +Anwaltskanzleien können Fallakten schnell finden, indem sie PDFs, Word‑Dokumente und E‑Mails indizieren. Durch **Verbesserung der Abfrageleistung** verbringen Anwälte weniger Zeit mit Warten auf Ergebnisse und mehr Zeit mit der Durchsicht des Inhalts. + +### Fallstudie 2: E‑Commerce‑Plattformen +Online‑Händler indizieren Produktbeschreibungen, Spezifikationen und Bewertungen. Korrekt escapete Abfragen ermöglichen Kunden die Suche nach Ausdrücken wie `4‑K TV` ohne Fehler, während schnelle Abfrageausführung das Einkaufserlebnis reibungslos hält. + +## Leistungsüberlegungen & Tipps + +- **Den Index aktualisieren** nach Massenimporten oder großen Updates, um die Suchlatenz niedrig zu halten. +- **Ausreichend Heap‑Speicher zuweisen** (`-Xmx2g` oder höher) für große Datensätze. +- **Die `Index`‑Instanz wiederverwenden** für mehrere Suchen, anstatt sie jedes Mal neu zu erstellen. +- **Abfrageausführung profilieren** mit den integrierten Java‑Tools, um Engpässe zu identifizieren. + +## Häufige Fallstricke & Lösungen + +| Problem | Warum es passiert | Lösung | +|-------|-------------------|--------| +| Abfragen liefern nach dem Hinzufügen neuer Dateien keine Ergebnisse | Index nicht aktualisiert | Rufen Sie `index.add(newPath)` auf oder bauen Sie den Index neu auf. | +| Fehler wegen unerwarteter Zeichen | Sonderzeichen nicht escaped | Stellen Sie sicher, dass die Escape‑Logik aus Schritt 5 vor der Suche ausgeführt wird. | +| Hoher Speicherverbrauch | Große Ergebnis‑Mengen werden auf einmal geladen | Durchlaufen Sie `searchResult.getDocuments()` lazy oder begrenzen Sie die Ergebnisse mit `index.search(query, 100)`. | + +## Häufig gestellte Fragen + +**Q: Wie gehe ich mit extrem großen Datensätzen in GroupDocs.Search um?** +A: Verwenden Sie inkrementelle Indizierung (`index.add`) und planen Sie periodische Indexoptimierungen. Setzen Sie den Index auf SSD‑Speicher, um schnellere I/O‑Leistung zu erzielen. + +**Q: Kann GroupDocs.Search in Spring Boot integriert werden?** +A: Ja. Definieren Sie das `Index`‑Bean in einer `@Configuration`‑Klasse und injizieren Sie es dort, wo Sie Suchfunktionen benötigen. + +**Q: Welche Zeichen müssen in einer Abfrage escaped werden?** +A: Die Zeichen `()":&|!^~*?` benötigen einen vorangestellten Backslash (`\`), um als Literale behandelt zu werden. + +**Q: Wie kann ich einen bestehenden Index mit neu hochgeladenen Dokumenten aktualisieren?** +A: Rufen Sie `index.add("NEW_DOCUMENT_DIRECTORY")` auf; die Bibliothek fügt neue Einträge hinzu, ohne den gesamten Index neu aufzubauen. + +**Q: Ist GroupDocs.Search für Echtzeit‑Suchszenarien geeignet?** +A: Absolut. Die Bibliothek unterstützt schnelle inkrementelle Updates und latenzarme Abfragen, was sie ideal für Live‑Suchfelder macht. + +## Ressourcen +- [Dokumentation](https://docs.groupdocs.com/search/java/) +- [API‑Referenz](https://reference.groupdocs.com/) + +--- + +**Zuletzt aktualisiert:** 2026-01-21 +**Getestet mit:** GroupDocs.Search Java 25.4 +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/german/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/german/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..947bc50f --- /dev/null +++ b/content/german/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,207 @@ +--- +date: '2026-01-21' +description: Erfahren Sie, wie Sie Shards mit GroupDocs.Search für Java optimieren, + das Suchnetzwerk konfigurieren, eine Textsuche durchführen und Portkonflikte behandeln. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Wie man Shards in GroupDocs.Search für Java optimiert: Ein umfassender Leitfaden' +type: docs +url: /de/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +, **wie man Shards optimiert**, führt zur Leistungsverbesserung, zur nahtlose Konfiguration und Optimierung Ihres Suchnetzwerks und verbessert sowohl die Leistung als auch die Benutzererfahrung. + +## Schnelle Antworten +- **Was ist Shard-Optimierung?** Sie reorganisiert Indexdaten, um Abfragen zu beschleunigen und den Speicheraufwand zu reduzieren. +- **Wie kon?** Definieren Sie ein Basisverzeichnis und einen Port und setzen Sie dann Knoten mit der bereitgestellten API ein. +- **Wie führe ich eine Textsuche durch?** Verwenden Sie `TextSearchInNetwork.searchAll` mit Ihrem Abfrage-String. +- **Wie indexiere ich Dokumente in Java?** Fügen Sie Dokumentverzeichnisse dem Master-Knoten mit `IndexingDocuments.addDirectories` hinzu. +- **Wie gehe ich mit Portkonflikten um?** Ändern Sie die Variable `basePort` zu einem nicht genutzten Port auf Ihrem Rechner. + +## Wie man ein Suchnetzwerk konfiguriert +Bevor Sie mit Indexierung und Suche beginnen, benötigen Sie eine solide Netzwerkgrundlage. Dieser Abschnitt erklärt die Schritte zum Einrichten des Netzwerks, zur Auswahl eines Ports und zum Vermeiden gängiger Port‑Konflikt‑Probleme. + +## Wie man Dokumente in Java indexiert +Sobald das Netzwerk läuft, besteht der nächste Schritt darin, es mit Inhalten zu füttern. Wir zeigen Ihnen, wie Sie mehrere Dokumentordner hinzufügen, damit die Engine einen durchsuchbaren Index erstellen kann. + +## Wie man eine Textsuche durchführt +Nach der Indexierung möchten Sie Informationen schnell abrufen. Dieser Abschnitt demonstriert die einfachste Methode, eine Textabfrage über alle Knoten hinweg auszuführen. + +## Wie man Portkonflikte behandelt +Wenn der Standardport (`49132`) bereits verwendet wird, ändern Sie einfach den Wert von `basePort` zu einem freien Port und starten Sie die Konfiguration neu. Dies verhindert Startfehler und hält Ihr Netzwerk stabil. + +## Voraussetzungen +Bevor wir beginnen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllt haben: + +### Erforderliche Bibliotheken, Versionen und Abhängigkeiten +Um diese Lösung zu implementieren, fügen Sie die GroupDocs.Search-Bibliothek über Maven hinzu, indem Sie die folgende Konfiguration zu Ihrer `pom.xml`-Datei hinzufügen: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Alternativ können Sie die neueste Version von [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) herunterladen. + +### Anforderungen an die Umgebungseinrichtung +- Stellen Sie sicher, dass Ihre Entwicklungsumgebung Java unterstützt (JDK 8 oder höher). +- Zugriff auf eine Netzwerkkonfiguration, die die Portnutzung erlaubt. + +### Wissensvoraussetzungen +Ein grundlegendes Verständnis der Java-Programmierung, einschließlich objektorientierter Prinzipien und Ausnahmebehandlung, ist für dieses Tutorial von Vorteil. + +## Einrichtung von GroupDocs.Search für Java +Um GroupDocs.Search in Ihrem Projekt zu verwenden, folgen Sie diesen Schritten: + +1. **Abhängigkeit hinzufügen**: Wie oben gezeigt, fügen Sie die notwendige Maven-Abhängigkeit zu Ihrem Projekt hinzu oder laden Sie sie direkt von der Release-Seite herunter. +2. **Lizenzbeschaffung**: + - Für eine kostenlose Testversion verwenden Sie die Bibliothek ohne Funktionsbeschränkungen, jedoch mit einigen Nutzungseinschränkungen. + - Erhalten Sie eine temporäre Lizenz für den vollen Funktionsumfang während der Evaluierung, indem Sie [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/) besuchen. + - Kaufen Sie eine Voll-Lizenz, wenn Sie planen, GroupDocs.Search in Ihrer Produktionsumgebung zu integrieren. +3. **Grundlegende Initialisierung und Einrichtung**: + Initialisieren Sie die Konfiguration mit der Klasse `Configuration`, indem Sie den Basis-Pfad für Dokumente festlegen und eine Portnummer angeben: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Implementierungsleitfaden +Nun wollen wir die Implementierung wichtiger Funktionen mit GroupDocs.Search Java untersuchen. + +### Funktion: Konfiguration des Suchnetzwerks +**Übersicht**: Das Einrichten eines Suchnetzwerks beinhaltet die Definition Ihres Dokumentverzeichnisses und dessen Konfiguration mit einem spezifischen Port für die Kommunikation zwischen Knoten. + +#### Schritt 1: Dokumentverzeichnisse und Port definieren +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Schritt 2: Suchnetzwerk konfigurieren +Erstellen Sie das Konfigurationsobjekt unter Verwendung der definierten Pfade: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Funktion: Bereitstellung von Suchnetzwerk-Knoten +**Übersicht**: Stellen Sie Knoten bereit, um Dokumentensuchen effizient über Ihr Netzwerk hinweg zu verarbeiten. + +#### Schritt 1: Knoten mit Konfiguration bereitstellen +Stellen Sie Suchnetzwerk-Knoten bereit und identifizieren Sie den Master-Knoten für die zentrale Verwaltung: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Funktion: Abonnieren von Netzwerk-Knoten-Ereignissen +**Übersicht**: Überwachen Sie Ihr Suchnetzwerk, indem Sie Ereignisse abonnieren, die Sie über wichtige Änderungen oder Aktionen informieren. + +#### Schritt 1: Master-Knoten-Ereignisse abonnieren +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Funktion: Indexierung von Dokumenten in Netzwerk-Knoten +**Übersicht**: Fügen Sie Verzeichnisse mit Dokumenten zum Indexierungsprozess hinzu, um effiziente Suchen zu ermöglichen. + +#### Schritt 1: Dokumentverzeichnisse zum Indexierungsprozess hinzufügen +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Funktion: Textsuche in Netzwerk-Knoten +**Übersicht**: Führen Sie Textsuchen über alle indexierten Dokumente in Ihrem Suchnetzwerk aus. + +#### Schritt 1: Textsuche durchführen +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Funktion: Optimierung von Shards +**Übersicht**: Verbessern Sie die Leistung, indem Sie Shards im Indexer Ihres Suchnetzwerk-Knotens optimieren. + +#### Schritt 1: Indexer-Shards optimieren +Optimieren Sie Shards, um die Sucheffizienz zu steigern (hier kommt **wie man Shards optimiert** wirklich zum Tragen): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Praktische Anwendungen +GroupDocs.Search für Java kann in verschiedenen realen Szenarien angewendet werden: + +1. **Unternehmens-Dokumentenmanagement**: Erleichtern Sie die Dokumentenabfrage über große Unternehmensdatenbanken. +2. **E‑Commerce-Plattformen**: Verbessern Sie die Produktsuche mit optimierten Indexierungs- und Abfragefunktionen. +3. **Rechtsanwaltskanzleien**: Verwalten und rufen Sie Fallakten und Dokumente aus umfangreichen Archiven effizient ab. +4. **Bibliothekssysteme**: Optimieren Sie den Katalogisierungsprozess, indem Sie sich in digitale Bibliothekssysteme integrieren für schnelle Suchen. +5. **Content-Management-Systeme (CMS)**: Verbessern Sie die Auffindbarkeit von Inhalten durch erweiterte Suchfunktionen. + +## Leistungsüberlegungen +Um die optimale Leistung Ihrer GroupDocs.Search-Implementierung sicherzustellen: +- Optimieren Sie regelmäßig Shards, um die Antwortzeiten von Abfragen zu reduzieren. +- Überwachen und verwalten Sie die Speichernutzung, insbesondere in Umgebungen mit großen Datensätzen. +- Befolgen Sie bewährte Java-Praktiken für Garbage Collection und Ressourcenmanagement, um die Systemeffizienz zu erhalten. + +## Fazit +Durch die Befolgung dieses umfassenden Leitfadens haben Sie gelernt, wie man ein Suchnetzwerk mit GroupDocs.Search für Java einrichtet und optimiert. Mit diesen Fähigkeiten können Sie nun effiziente Dokumentensuchen in verschiedenen Anwendungen durchführen und die Leistung sowie die Benutzererfahrung Ihres Projekts verbessern. Um die Möglichkeiten von GroupDocs.Search weiter zu erkunden, in Betracht ziehen oder zusätzliche Funktionen in ihrer Dokumentation prüfen. + +## FAQ-Bereich +1. **Was ist Shard-Optimierung?. +2. **Wie gehe ich mit Portkonflikten bei der Konfiguration eines Suchnetzwerks um?** + - Ändern Sie die Variable basePort zu einem nicht gen den Konfigurationsprozess neu. +3. **Kann GroupDocs.Search in bestehende Java-Anwendungen integriert werden?** + - Ja, es kann nahtlos integriert werden, indem Sie die Bibliotheksabhängigkeit in Ihr Projekt einbinden. +4. **Welche häufigen Probleme treten bei der Einrichtung auf?** + - Häufige Probleme umfassen falsche Portkonfigurationen und fehlende Abhängigkeiten; stellen Sie sicher, dass Sie die Voraussetzungen genau befolgen. + +## Häufig gestellte Fragen + +**Q: Wie wirkt sich die Shard-Optimierung auf die Abfragegeschwindigkeit aus?** +A: Die Optimierung von Shards komprimiert den Index, reduziert die Festplatten‑I/O und führt typischerweise zu schnelleren Abfrageantworten. + +**Q: Ist es sicher, `optimizeShards` auf einem Live‑Knoten auszuführen?** +A: Ja, die Operation ist so konzipiert, dass sie ohne Ausfallzeiten läuft, jedoch sollte sie für große Indizes während Zeiten mit geringem Datenverkehr geplant werden. + +**Q: Kann ich die `OptimizeOptions` anpassen?** +A: Absolut. Sie können Parameter wie `maxSegmentSize` oder `mergeFactor` festlegen, um den +A: Überprüfen Sie die Dateisystemberechtigungen, stellen Sie sicher, dass ausreichend Speicherplatz vorhanden ist, und bestätigen Sie, dass kein anderer Prozess die Indexdateien sperrt. + +**Q: Gibt die Optimierung von Shards auch den Speicherplatz gelöschter Dokumente zurück?** +A: Ja, der Optimierer führt Segmente zusammen und entfernt Tombstones, wodurch der von gelöschten Dokumenten belegte Speicherplatz freigegeben wird. + +--- + +**Zuletzt aktualisiert:** 2026-01-21 +**Getestet mit:** GroupDocs.Search 25.4 für Java +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/hindi/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md b/content/hindi/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md new file mode 100644 index 00000000..cc74c2c7 --- /dev/null +++ b/content/hindi/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md @@ -0,0 +1,219 @@ +--- +date: '2026-01-21' +description: GroupDocs Maven निर्भरता को जोड़ना, Java सर्च नेटवर्क को कॉन्फ़िगर और + सिंक्रनाइज़ करना, तथा GroupDocs.Search के साथ इंडेक्स करने के लिए डायरेक्टरी जोड़ना + सीखें। +keywords: +- Java Search Network Configuration +- GroupDocs.Search for Java +- Document Indexing and Retrieval +title: GroupDocs Maven निर्भरता – जावा सर्च नेटवर्क सिंक +type: docs +url: /hi/java/search-network/java-groupdocs-search-configuration-sync-guide/ +weight: 1 +--- + +# GroupDocs Maven Dependency: जावा सर्च नेटवर्क्स को कॉन्फ़िगर करना और सिंक्रनाइज़ करना + +इस व्यापक गाइड में कुशलता से सिंक रखनेड़ी इंटीग्रेट करके आप एक शक्तिशाली इंडेक्सिंग इंजन प्राप्त करते हैं जो कई नोड्स में स्केल करता है। यह ट्यूटोरियल आपको डिपेंडेंसी सेट अप करने, नेटवर्क नोड्स डिप्लॉय करने, इंडेक्स में डायरेक्टरी जोड़ने और इष्टतम प्रदर्शन के लिए शार्ड्स को सिंक्रनाइज़ करने की प्रक्रिया दिखाता है। + +### Quick Answers +- **GroupDocs Maven Dependency क्या है?** एक Maven आर्टिफैक्ट जो GroupDocs.Search लाइब्रेरी को आपके जावा प्रोजेक्ट में लाता है। +- **सर्च नेटवर्क क्यों उपयोग करें?** यह इंडेक्सिंग और क्वेरी लोड को कई नोड्स में वितरित करता है, जिससे गति और विश्वसनीयता बढ़ती है। +- **इंडेक्स में डायरेक्टरी कैसे जोड़ें?** मास्टर नोड उपयोग करें। +- **शार्ड लाइसेंस चाहिए?** हाँ, प्रोडक्शन उपयोग के लिए ट्रायल या कमर्शियल लाइसेंस आवश्यक है। + +## What is the GroupDocs Maven Dependency? + +GroupDocs Maven Dependency (`com.groupdocs:groupdocs-search`) वह पैकेज है जिसमें सभी क्लासेज़ शामिल हैं जो सर्चेबल इंडेक्स बनाने, नेटवर्क नोड्स को मैनेज करने और तेज़ क्वेरीज़ करने के लिए आवश्यक हैं। इसे अपने `pom.xml` में जोड़ने से Maven सही बाइनरीज़ और ट्रांज़िटिव डिपेंडेंसीज़ को पुल करता है। + +## How to Add the GroupDocs Maven Dependency + +### Maven Configuration + +अपने `pom.xml` में रिपॉज़िटरी और डिपेंडेंसी जोड़ें: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +> **Pro tip:** आधिकारिक रिलीज़ पेज पर जाकर संस्करण संख्या को हमेशा अपडेट रखें। + +आप आधिकारिक साइट से सीधे JAR भी डाउनलोड कर सकते हैं: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/)। + +## Prerequisites + +- **JDK** (11 या नया) स्थापित हो। +- IntelliJ IDEA या Eclipse जैसे IDE। +- बेसिक जावा नॉलेज, Maven की समझ, और नेटवर्क नोड कॉन्सेप्ट्स की जानकारी। +- वैध GroupDocs.Search लाइसेंस (फ्री ट्रायल या कमर्शियल)। + +## Basic Initialization and Setup + +इंडेक्स डायरेक्टरी बनाकर शुरू करें: + +```java +import com.groupdocs.search.SearchIndex; +import com.groupdocs.search.options.IndexingOptions; + +// Create an index in the specified directory +SearchIndex index = new SearchIndex("YOUR_INDEX_DIRECTORY"); +``` + +यह सरल कदम अगले नेटवर्क कॉन्फ़िगरेशन के लिए वातावरण तैयार करता है। + +## Implementation Guide + +### Feature 1: Configuration of Search Network + +#### Overview + +सर्च नेटवर्क को कॉन्फ़िगर करने से फ़ाइल पाथ्स और पोर्ट्स सेट होते हैं जो नोड्स संचार के लिए उपयोग करेंगे। + +##### Set Up Paths and Ports +```java +import com.groupdocs.search.options.*; +import com.groupdocs.search.scaling.configuring.ConfiguringSearchNetwork; + +// Set custom paths for input/output directories +String basePath = "YOUR_DOCUMENT_DIRECTORY/AdvancedUsage/Scaling/SynchronizingShards/"; +int basePort = 49144; // Adjust if there's a port conflict + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` +`configuration` ऑब्जेक्ट अब आपके सर्च नेटवर्क के सभी आवश्यक सेटिंग्स रखता है। + +### Feature 2: Deploying Search Network Nodes + +#### Overview + +वर्कलोड को अपने नेटवर्क में वितरित करने के लिए नोड्स डिप्लॉय करें। मास्टर नोड ऑपरेशन्स और इवेंट्स को मैनेज करता है। + +##### Deployment Code +```java +import com.groupdocs.search.scaling.*; +import com.groupdocs.search.options.Configuration; + +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +// Retrieve the master node for further operations +SearchNetworkNode masterNode = nodes[0]; +``` + +### Feature 3: Subscribing to Search Network Node Events + +#### Overview + +इवेंट्स को सुनने से नेटवर्क में बदलाव या अपडेट को डायनामिक रूप से हैंडल किया जा सकता है। + +##### Subscription Implementation +```java +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.scaling.SearchNetworkNodeEvents; + +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Feature 4: Adding Directories to Index + +#### Overview + +डायरेक्टरी जोड़ना वह मुख्य कदम है जिससे आपके दस्तावेज़ सर्चेबल बनते हैं। + +##### Document Addition +```java +import com.groupdocs.search.indexing.IndexingDocuments; +import com.groupdocs.search.scaling.SearchNetworkNode; + +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +``` + +### Feature 5: Synchronizing Shards in Search Network Node + +#### Overview + +सिंक्रनाइज़ेशन सभी शार्ड्स में डेटा कंसिस्टेंसी सुनिश्चित करता है। + +##### Synchronization Code +```java +import com.groupdocs.search.indexing.Indexer; +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.options.SynchronizeOptions; + +SearchNetworkNode node = null; // Assume 'node' is initialized as a SearchNetworkNode + +def synchronizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + SynchronizeOptions options = new SynchronizeOptions(); + indexer.synchronize(options); +} +``` + +### Feature 6: Closing Search Network Nodes + +#### Overview + +नोड्स को सही तरीके से बंद करने से रिसोर्सेज़ रिलीज़ होते हैं और मेमोरी लीक्स रोकते हैं। + +##### Node Closure +```java +import com.groupdocs.search.scaling.SearchNetworkNode; + +for (SearchNetworkNode node : nodes) { + node.close(); +} +``` + +## Practical Applications + +1. **Legal Document Management** – केस फ़ाइल्स और प्रीसिडेंट्स को जल्दी से रिट्रीव करें। +2. **Financial Record Keeping** – स्टेटमेंट्स और ऑडिट ट्रेल्स को सेकंड्स में एक्सेस करें। +3. **Academic Research** – हजारों पेपरों में खोज कर प्रासंगिक सिटेशन्स खोजें। + +## Performance Considerations + +- **Optimize Queries** – रिस्पॉन्स टाइम कम करने के लिए संक्षिप्त क्वेरीज़ लिखें। +- **Memory Management** – JVM हीप उपयोग मॉनिटर करें; बड़े इंडेक्स के लिए GC ट्यूनिंग पर विचार करें। +- **Scaling Strategy** –ोड के अनुसार नोड्स को प्रोप to connect | Port conflict | `basePort` को किसी अनयूज़्ड वैल्यू में बदलें | +| Index not updating | Event subscription missing | सुनिश्चित करें कि `SearchNetworkNodeEvents.subscribe(masterNode)` कॉल किया गया है | +| High latency | Insufficient shards | नोड्स की संख्या बढ़ाएँ और डॉक्यूमेंट डिस्ट्रिब्यूशन बैलेंस करें | + +## Frequently Asked Questions + +**Q: GroupDocs.Search उपयोग करने का मुख्य लाभ क्या है?** +A: यह बड़े दस्तावेज़ सेट्स में तेज़, स्केलेबल सर्च क्षमताएँ प्रदान करता है, जिसमें न्यूनतम कॉन्फ़िगरेशन की आवश्यकता होती है। + +**Q: क्या सर्च नेटवर्क में नोड कॉन्फ़िगरेशन कस्टमाइज़ कर सकते हैं?** +A: हाँ, आप `Configuration` ऑब्जेक्ट के माध्यम से कस्टम पाथ्स, पोर्ट्स और अन्य विकल्प सेट कर सकते हैं। + +**Q: नेटवर्क चल रहा हो तो डायरेक्टरी कैसे जोड़ें?** +A: जब भी नई फ़ोल्डर इंडेक्स करनी हो, `IndexingDocuments.addDirectories(masterNode, "path")` कॉल करें। + +**Q: नया नोड जुड़ने पर शार्ड्स को कैसे सिंक करें?** +A: ऊपर दिखाए गए `synchronizeShards` मेथड को नए जोड़े गए नोड पर उपयोग करें। + +**Q: विकास के लिए लाइसेंस चाहिए?** +A: टेस्टिंग के लिए फ्री ट्रायल लाइसेंस पर्याप्त है; प्रोडक्शन के लिए कमर्शियल लाइसेंस आवश्यक है। + +## Conclusion + +इस गाइड को फॉलो करके आप अब **GroupDocs Maven Dependency को जोड़ना**, मल्टी‑नोड सर्च नेटवर्क कॉन्फ़िगर करना, डायरेक्टरीज़ को इंडेक्स करना और शार्ड्स को सिंक्रनाइज़ रखना जानते हैं। ये कदम एक हाई‑परफ़ॉर्मेंस डॉक्यूमेंट सर्च सॉल्यूशन की नींव रखते हैं, जो आपके संगठन की जरूरतों के साथ बढ़ सकता है। + +--- + +**Last Updated:** 2026-01-21 +**Tested With:** GroupDocs.Search 25.4 +**Author:** GroupDocs \ No newline at end of file diff --git a/content/hindi/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/hindi/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..be8db8e0 --- /dev/null +++ b/content/hindi/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,209 @@ +--- +date: '2026-01-21' +description: GroupDocs.Search for Java का उपयोग करके शार्ड्स को अनुकूलित करना सीखें, + सर्च नेटवर्क को कॉन्फ़िगर करना, टेक्स्ट सर्च करना और पोर्ट कॉन्फ्लिक्ट को संभालना। +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'GroupDocs.Search for Java में शार्ड्स को कैसे ऑप्टिमाइज़ करें: एक व्यापक गाइड' +type: docs +url: /hi/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# शार्ड्स को ऑप्टिमाइज़ करने के लिए GroupDocs.Search for Java में: एक व्यापक गाइड + +प्रभावी दस्तावेज़ खोज डेवलपर्स और उन व्यवसायों के लिए आवश्यक है जो बड़े डेटाबेस का प्रबंधन करते हैं या आंतरिक दस्तावेज़ पुनर्प्राप्ति प्रक्रियाओं को सरल बनाना चाहते हैं। यदि आप **शार्ड्स को कैसे ऑप रहे हैं, तो यह गाइड आपको प्रदर्शन सुधारने, अपने सर्च नेटवर्क को कॉन्फ़िगर करने, और पोर्ट कॉन्फ्लिक्ट जैसी सामान्य चुनौतियों को संभालने के और ऑप्टिमाइज़ेशन प्रदान करता है, जिससे प्रदर्शन और उपयोगकर्ता अनुभव दोनों में सुधार होता है। + +## त्वरित उत्तर +- **शार्ड ऑप्टिमाइज़ेशन क्या है?** यह इंडेक्स डेटा को पुनः व्यवस्थित करता है ताकि क्वेरीज़ तेज़ हों और स्टोरेज ओवरहेड कम हो। +- **सर्च नेटवर्क को कैसे कॉन्फ़िगर करें?** बेस डायरेक्टरी और पोर्ट को परिभाषित करें, फिर प्रदान किए गए API का उपयोग करके नोड्स को डिप्लॉय करें। +- **टेक्स्ट सर्च कैसे करें?** अपने क्वेरी स्ट्रिंग के साथ `TextSearchInNetwork.searchAll` का उपयोग करें। +- **जावा में दस्तावेज़ों को कैसे इंडेक्स करें?** `IndexingDocuments.addDirectories` के साथ दस्तावेज़ डायरेक्टरी को मास्टर नोड में जोड़ें। +- **पोर्ट कॉन्फ्लिक्ट को कैसे संभालें?** `basePort` वैरिएबल को अपने मशीन पर एक अनउपयोगी पोर्ट में बदलें। + +## सर्च नेटवर्क को कैसे कॉन्फ़िगर करें +इंडेक्सिंग और सर्चिंग में डुबने से पहले, आपको एक ठोस नेटवर्क बुनियाद की आवश्यकता होती है। यह सेक्शन नेटवर्क सेटअप करने, पोर्ट चुनने, और सामान्य पोर्ट‑कॉन्फ्लिक्ट समस्याओं से बचने के चरणों को समझाता है। + +## जावा में दस्तावेज़ों को कैसे इंडेक्स करें +एक बार नेटवर्क तैयार हो जाने के बाद, अगला कदम इसे सामग्री से भरना है। हम आपको दिखाएंगे कि कई दस्तावेज़ फ़ोल्डर्स कैसे जोड़ें ताकि इंजन एक सर्चेबल इंडेक्स बना सके। + +## टेक्स्ट सर्च कैसे करें +इंडेक्सिंग के बाद, आप जानकारी को जल्दी से प्राप्त करना चाहेंगे। यह भाग सभी नोड्स पर टेक्स्ट क्वेरी चलाने का सबसे सरल तरीका दर्शाता है। + +## पोर्ट कॉन्फ्लिक्ट को कैसे संभालें +यदि डिफ़ॉल्ट पोर्ट (`49132`) पहले से उपयोग में है, तो बस `basePort` वैल्यू को एक मुक्त पोर्ट में बदलें और कॉन्फ़िगरेशन को पुनः शुरू करें। इससे स्टार्टअप त्रुटियों से बचा जा सकता है और आपका नेटवर्क स्थिर रहता है। + +## पूर्वापेक्षाएँ +शुरू करने से पहले, सुनिश्चित करें कि आपके पास निम्नलिखित पूर्वापेक्षाएँ मौजूद हैं: + +### आवश्यक लाइब्रेरीज़, संस्करण, और निर्भरताएँ +इस समाधान को लागू करने के लिए, Maven का उपयोग करके GroupDocs.Search लाइब्रेरी को शामिल करें, अपने `pom.xml` फ़ाइल में निम्नलिखित कॉन्फ़िगरेशन जोड़कर: + +```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 (JDK 8 या बाद का) का समर्थन करता है। +- पोर्ट उपयोग की अनुमति देने वाली नेटवर्क कॉन्फ़िगरेशन तक पहुंच। + +### ज्ञान पूर्वापेक्षाएँ +Java प्रोग्रामिंग की बुनियादी समझ, जिसमें ऑब्जेक्ट‑ओरिएंटेड सिद्धांत और एक्सेप्शन हैंडलिंग शामिल हैं, इस ट्यूटोरियल के लिए उपयोगी होगी। + +## GroupDocs.Search for Java सेटअप करना +अपने प्रोजेक्ट में GroupDocs.Search का उपयोग शुरू करने के लिए, इन चरणों का पालन करें: + +1. **डिपेंडेंसी जोड़ें**: जैसा कि ऊपर दिखाया गया है, आवश्यक Maven डिपेंडेंसी को अपने प्रोजेक्ट में जोड़ें या रिलीज़ पेज से सीधे डाउनलोड करें। +2. **लाइसेंस प्राप्त करना**: + - फ्री ट्रायल के लिए, लाइब्रेरी को फीचर प्रतिबंधों के बिना उपयोग करें, लेकिन कुछ उपयोग सीमाएँ होंगी। + - मूल्यांकन के दौरान पूर्ण फीचर एक्सेस के लिए एक अस्थायी लाइसेंस प्राप्त करने हेतु [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/) पर जाएँ। + - यदि आप GroupDocs.Search को प्रोडक्शन पर्यावरण में एकीकृत करने का निर्णय लेते हैं तो पूर्ण लाइसेंस खरीदें। +3. **बेसिक इनिशियलाइज़ेशन और सेटअप**: + `Configuration` क्लास का उपयोग करके कॉन्फ़िगरेशन को इनिशियलाइज़ करें, दस्तावेज़ों के बेस पाथ को सेट करें और पोर्ट नंबर निर्दिष्ट करें: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## कार्यान्वयन गाइड +अब हम GroupDocs.Search Java का उपयोग करके प्रमुख फीचर्स के कार्यान्वयन को देखें। + +### फीचर: सर्च नेटवर्क को कॉन्फ़िगर करना +**अवलोकन**: सर्च नेटवर्क सेटअप करने में आपके दस्तावेज़ डायरेक्टरी को परिभाषित करना और नोड्स के बीच संचार के लिए एक विशिष्ट पोर्ट के साथ कॉन्फ़िगर करना शामिल है। + +#### Step 1: Define Document Directories and Port +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Step 2: Configure Search Network +परिभाषित पाथ्स का उपयोग करके कॉन्फ़िगरेशन ऑब्जेक्ट बनाएं: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### फीचर: सर्च नेटवर्क नोड्स को डिप्लॉय करना +**अवलोकन**: नोड्स को डिप्लॉय करें ताकि आपके नेटवर्क में दस्तावेज़ खोज को कुशलता से संभाला जा सके। + +#### Step 1: Deploy Nodes Using Configuration +सर्च नेटवर्क नोड्स को डिप्लॉय करें और केंद्रीकृत प्रबंधन के लिए मास्टर नोड की पहचान करें: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### फीचर: नेटवर्क नोड इवेंट्स की सदस्यता लेना +**अवलोकन**: महत्वपूर्ण बदलाव या क्रियाओं की सूचना देने वाले इवेंट्स की सदस्यता लेकर अपने सर्च नेटवर्क की निगरानी करें। + +#### Step 1: Subscribe to Master Node Events +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### फीचर: नेटवर्क नोड्स में दस्तावेज़ों को इंडेक्स करना +**अवलोकन**: कुशल खोज के लिए दस्तावेज़ों वाले डायरेक्टरी को इंडेक्सिंग प्रक्रिया में जोड़ें। + +#### Step 1: Add Document Directories to Indexing Process +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### फीचर: नेटवर्क नोड्स में टेक्स्ट सर्च +**अवलोकन**: अपने सर्च नेटवर्क के भीतर सभी इंडेक्स किए गए दस्तावेज़ों पर टेक्स्ट क्वेरी निष्पादित करें। + +#### Step 1: Perform a Text Search +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### फीचर: शार्ड्स को ऑप्टिमाइज़ करना +**अवलोकन**: अपने सर्च नेटवर्क नोड के इंडेक्सर में शार्ड्स को ऑप्टिमाइज़ करके प्रदर्शन में सुधार करें। + +#### Step 1: Optimize Indexer Shards +शार्ड्स को ऑप्टिमाइज़ करें ताकि सर्च दक्षता बढ़े (यही वह जगह है जहाँ **शार्ड्स को कैसे ऑप्टिमाइज़ करें** वास्तव में मायने रखता है): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## व्यावहारिक अनुप्रयोग +GroupDocs.Search for Java को विभिन्न वास्तविक‑विश्व परिदृश्यों में लागू किया जा सकता है: +1. **एंटरप्राइज़ दस्तावेज़ प्रबंधन**: बड़े कॉरपोरेट डेटाबेस में दस्तावेज़ पुनर्प्राप्ति को सुविधाजनक बनाता है। +2. **ई‑कॉमर्स प्लेटफ़ॉर्म**: ऑप्टिमाइज़्ड इंडेक्सिंग और क्वेरी फीचर्स के साथ प्रोडक्ट सर्च क्षमताओं को बढ़ाता है। +3. **लीगल फर्म्स**: बड़े अभिलेखागार से केस फ़ाइलों और दस्तावेज़ों को कुशलता से प्रबंधित और पुनः प्राप्त करता है। +4. **लाइब्रेरी सिस्टम**: डिजिटल लाइब्रेरी सिस्टम के साथ एकीकृत करके तेज़ सर्च के लिए कैटलॉगिंग प्रक्रिया को सरल बनाता है। +5. **कंटेंट मैनेजमेंट सिस्टम (CMS)**: उन्नत सर्च क्षमताओं के माध्यम से कंटेंट की खोजयोग्यता में सुधार करता है। + +## प्रदर्शन संबंधी विचार +अपने GroupDocs.Search इम्प्लीमेंटेशन के इष्टतम प्रदर्शन को सुनिश्चित करने के लिए: +- क्वेरी प्रतिक्रिया समय को कम करने के लिए नियमित रूप से शार्ड्स को ऑप्टिमाइज़ करें। +- विशेष रूप से बड़े डेटासेट को संभालने वाले पर्यावरण में मेमोरी उपयोग की निगरानी और प्रबंधन करें। +- सिस्टम दक्षता बनाए रखने के लिए गार्बेज कलेक्शन और रिसोर्स मैनेजमेंट के लिए Java सर्वश्रेष्ठ प्रथाओं का पालन करें। + +## निष्कर्ष +इस व्यापक गाइड का पालन करके, आपने GroupDocs.Search for Java का उपयोग करके सर्च नेटवर्क को सेटअप और ऑप्टिमाइज़ करना सीख लिया है। इन कौशलों के साथ, आप अब विभिन्न अनुप्रयोगों में कुशल दस्तावेज़ खोज को संभालने के लिए तैयार हैं, जिससे आपके प्रोजेक्ट का प्रदर्शन और उपयोगकर्ता अनुभव दोनों में सुधार होगा। GroupDocs.Search की क्षमताओं का और अधिक अन्वेषण करने के लिए, इसे अन्य सिस्टम के साथ एकीकृत करने या उनके दस्तावेज़ में उपलब्ध अतिरिक्त फीचर्स को देखना विचार करें। + +## FAQ Section +1. **शार्ड ऑप्टिमाइज़ेशन क्या है?** + - शार्ड ऑप्टिमाइज़ेशन प्रत्येक शार्ड के भीतर डेटा को अधिक कुशलता से व्यवस्थित करके सर्च नेटवर्क के प्रदर्शन को सुधारता है। +2. **सर्च नेटवर्क को कॉन्फ़िगर करते समय पोर्ट कॉन्फ्लिक्ट को कैसे संभालें?** + - `basePort` वैरिएबल को अपने सिस्टम पर एक अनउपयोगी पोर्ट में बदलें और कॉन्फ़िगरेशन प्रक्रिया को पुनः शुरू करें। +3. **क्या GroupDocs.Search को मौजूदा Java एप्लिकेशन में एकीकृत किया जा सकता है?** + - हाँ, लाइब्रेरी डिपेंडेंसी को अपने प्रोजेक्ट में शामिल करके इसे सहजता से एकीकृत किया जा सकता है। +4. **सेटअप के दौरान कौन सी सामान्य समस्याएँ आती हैं?** + - सामान्य समस्याओं में गलत पोर्ट कॉन्फ़िगरेशन और डिपेंडेंसी की कमी शामिल हैं; सुनिश्चित करें कि आप पूर्वापेक्षाओं का सटीक पालन करें। + +## अक्सर पूछे जाने वाले प्रश्न +**Q: शार्ड ऑप्टिमाइज़ेशन क्वेरी स्पीड को कैसे प्रभावित करता है?** +A: शार्ड्स को ऑप्टिमाइज़ करने से इंडेक्स संकुचित होता है, डिस्क I/O कम होता है, और आमतौर पर तेज़ क्वेरी प्रतिक्रियाएँ मिलती हैं। + +**Q: क्या लाइव नोड पर `optimizeShards` चलाना सुरक्षित है?** +A: हाँ, यह ऑपरेशन बिना डाउनटाइम के चलाने के लिए डिज़ाइन किया गया है, लेकिन बड़े इंडेक्स के लिए कम ट्रैफ़िक वाले समय पर शेड्यूल करना बेहतर है। + +**Q: क्या मैं `OptimizeOptions` को कस्टमाइज़ कर सकता हूँ?** +A: बिल्कुल। आप `maxSegmentSize` या `mergeFactor` जैसे पैरामीटर सेट करके ऑप्टिमाइज़ेशन प्रक्रिया को फाइन‑ट्यून कर सकते हैं। + +**Q: ऑप्टिमाइज़ेशन के दौरान यदि `IOException` आए तो क्या करें?** +A: फ़ाइल सिस्टम अनुमतियों की जाँच करें, पर्याप्त डिस्क स्पेस सुनिश्चित करें, और पुष्टि करें कि कोई अन्य प्रक्रिया इंडेक्स फ़ाइलों को लॉक नहीं कर रही है। + +**Q: क्या शार्ड्स को ऑप्टिमाइज़ करने से हटाए गए दस्तावेज़ों की जगह भी मुक्त होती है?** +A: हाँ, ऑप्टिमाइज़र सेगमेंट्स को मर्ज करता है और टॉम्बस्टोन्स को हटाता है, जिससे हटाए गए दस्तावेज़ों द्वारा घिरी जगह मुक्त हो जाती है। + +--- + +**अंतिम अपडेट:** 2026-01-21 +**परिक्षण किया गया:** GroupDocs.Search 25.4 for Java +**लेखक:** GroupDocs \ No newline at end of file diff --git a/content/hongkong/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/hongkong/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..a3ae209c --- /dev/null +++ b/content/hongkong/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,186 @@ +--- +date: '2026-01-21' +description: 了解如何使用 GroupDocs.Search for Java 優化分片，並學習如何配置搜尋網絡、執行文字搜尋以及處理埠衝突。 +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 如何在 GroupDocs.Search for Java 中優化分片：全面指南 +type: docs +url: /zh-hant/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# 如何在 GroupDocs.Search for Java 中優化分片：完整指南 + +高效的文件搜尋對於管理大型資料庫或希望簡化內部文件檢索流程的開發者與企業而言至關重要。如果你在思考 **how to optimize shards**，本指南將逐步說明如何提升效能、設定搜尋網路，以及處理常見的埠衝突等挑戰。**GroupDocs.Search Java** 提供無縫的搜尋網路配置與優化，提升效能與使用者體驗。 + +## Quick Answers +- **什麼是分片優化？** 它會重新組織索引資料，以加快查詢速度並減少儲存開銷。 +- **如何配置搜尋網路？** 定義基礎目錄與埠號，然後使用提供的 API 部署節點。 +- **如何執行文字搜尋？** 使用 `TextSearchInNetwork.searchAll` 並傳入查詢字串。 +- **如何在 Java 中索引文件？** 使用 `IndexingDocuments.addDirectories` 將文件目錄加入主節點。 +- **如何處理埠衝突？** 將 `basePort` 變數改為機器上未使用的埠號。 + +## How to Configure Search Network +在深入索引與搜尋之前，你需要一個穩固的網路基礎。本節說明設定網路、選擇埠號以及避免常見埠衝突問題的步驟。 + +## How to Index Documents Java +網路啟動後，下一步是為其提供內容。我們將示範如何加入多個文件資料夾，讓引擎建立可搜尋的索引。 + +## How to Perform Text Search +完成索引後，你會希望快速取得資訊。本部分展示在所有節點上執行文字查詢的最簡方式。 + +## How to Handle Port Conflicts +如果預設埠 (`49132`) 已被佔用，只需將 `basePort` 值改為空閒埠，然後重新啟動配置。這可防止啟動錯誤，保持網路穩定。 + +## Prerequisites +在開始之前，請確保已具備以下前置條件： + +### Required Libraries, Versions, and Dependencies +要實作本解決方案，請在 `pom.xml` 中加入 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 Requirements +- 確保開發環境支援 Java（JDK 8 以上）。 +- 具備允許使用埠號的網路配置。 + +### Knowledge Prerequisites +具備基本的 Java 程式設計知識，包括物件導向原則與例外處理，將有助於本教學的學習。 + +## Setting Up GroupDocs.Search for Java +要在專案中使用 GroupDocs.Search，請依照以下步驟操作： + +1. **Add the Dependency**: 如上所示，將必要的 Maven 依賴加入專案，或直接從發行頁面下載。 +2. **License Acquisition**: + - 免費試用版可在功能上無限制使用，但會有使用量限制。 + - 前往 [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/) 取得暫時授權，以完整體驗所有功能。 + - 若決定在正式環境中使用，請購買正式授權。 +3. **Basic Initialization and Setup**: + 使用 `Configuration` 類別初始化設定，指定文件的基礎路徑並設定埠號： + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Implementation Guide +現在讓我們探討使用 GroupDocs.Search Java 實作關鍵功能的步驟。 + +### Feature: Configuring Search Network +**Overview**: 設定搜尋網路時，需要定義文件目錄，並以特定埠號進行節點間通訊。 + +#### Step 1: Define Document Directories and Port +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Step 2: Configure Search Network +使用先前定義的路徑建立配置物件： + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Feature: Deploying Search Network Nodes +**Overview**: 部署節點以在整個網路中有效處理文件搜尋。 + +#### Step 1: Deploy Nodes Using Configuration +部署搜尋網路節點，並辨識出作為集中管理的主節點： + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Feature: Subscribing to Network Node Events +**Overview**: 透過訂閱事件來監控搜尋網路的關鍵變更或操作。 + +#### Step 1: Subscribe to Master Node Events +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Feature: Indexing Documents in Network Nodes +**Overview**: 將包含文件的目錄加入索引流程，以提升搜尋效率。 + +#### Step 1: Add Document Directories to Indexing Process +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Feature: Text Search in Network Nodes +**Overview**: 在搜尋網路內的所有已索引文件上執行文字搜尋。 + +#### Step 1: Perform a Text Search +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Feature: Optimizing Shards網路節點索引器內的 optimize shards** 的關鍵所在）： + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Practical Applications +GroupDocs.Search for Java 可應用於各種實務情境： +1. **企業文件管理**：在大型企業資料庫中促進文件檢索。 +2. **電子商務平台**：利用優化的索引與查詢功能提升商品搜尋能力。 +3. **法律事務所**：高效管理與檢索大量案件檔案與文件。 +4. **圖書館系統**：結合數位圖書館系統，快速搜尋目錄資料。 +5. **內容管理系統 (CMS)**：透過進階搜尋功能提升內容可發現性。 + +## Performance Considerations +為確保 Group要點： +- 定期優化分片，以縮短查詢回應時間。 +- 監控並管理記憶體使用量，特別是在處理大型資料集的環境中。 +- 遵循 Java 的垃圾回收與資源管理最佳實踐，維持系統效率。 + +## Conclusion +透過本完整指南，你已學會如何使用 GroupDocs.Search for Java 建立與優化搜尋網路。掌握這些技能後，你能在各種應用場景中執行高效的文件搜尋，提升專案效能與使用者體驗。欲進一步探索與其他系統整合，或深入研究其文件中提供的其他進階功能。 + +## FAQ Section +1.資料，提升搜尋網路的效能。 +2. **設定搜尋網路時如何處理埠衝突？**常見的問題有哪些？** + - 常見問題包括埠號設定錯誤與缺少依賴套查詢會壓縮索引、減少磁碟 I/O，通常能帶來更快的查詢回應。 + +**Q: 在線上節點上執行 `optimizeShards` 安全嗎？** +A: 安全，該操作設計為可在不中斷服務的情況下執行，但對於大型索引，建議在低流量時段安排。 + +**Q: 我可以自訂 `OptimizeOptions` 嗎？** +A: 當然可以。你可以設定 `maxSegmentSize`、`merge。 + +**Q: 若在優化過程中遇到 `IOException`，該怎麼辦？** +A: 請檢查檔案系統權限、確保磁回收已 \ No newline at end of file diff --git a/content/hungarian/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/hungarian/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md new file mode 100644 index 00000000..55a3298e --- /dev/null +++ b/content/hungarian/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -0,0 +1,220 @@ +--- +date: '2026-01-21' +description: Tanulja meg, hogyan javíthatja a lekérdezés teljesítményét, és hogyan + adhat dokumentumokat az indexhez, miközben helyesen escape-eli a speciális karaktereket + a lekérdezésben a GroupDocs.Search Java használatával. +keywords: +- GroupDocs.Search Java +- document index optimization +- search query performance +title: 'A lekérdezési teljesítmény javítása a GroupDocs.Search Java-val: index és + keresés optimalizálása' +type: docs +url: /hu/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/ +weight: 1 +--- + +# Kérdezési teljesítmény javítása a GroupDocs.Search Java-val: Index és keresés optimalizálása + +A hatalmas dokumentumgyűjtemény hatékony kezelése a **kérdezési teljesítmény javításával** kezdődik. Ebben az útmutatóban megtudja, hogyan hozhat létre és konfigurálhat nagy teljesítményű indexet, **hogyan adhat dokumentumokat az indexhez**, és hogyan **szökje meg a speciális karaktereket a lekérdezésben**, hogy a keresések gyorsan fussonak és pontos eredményeket adjanak. Legyen szó vállalati tudásbázis vagy kereshető e‑kereskedelmi katalógus építéséről, ezeknek a lépéseknek a elsajátítása biztosítja, hogy alkalmazása nagy terhelés alatt is reagálékony maradjon. + +## Gyors válaszok +- **Mi a fő cél?** A kérdezési teljesítmény javítása az index és a lekérdezéskezelés finomhangolásával. +- **Melyik könyvtárat használja?** GroupDocs.Search for Java. +- **Szükség van licencre?** Fejlesztéshez egy ingyenes próba vagy ideiglenes licenc elegendő; termeléshez teljes licenc szükséges. +- **Hogyan adhatok dokumentumokat?** Használja a `index.add("YOUR_DOCUMENT_DIRECTORY")` metódust a kötegelt fájlbetöltéshez. +- **Hogyan kezelik a speciális karaktereket?** Állítsa be az ábécé‑szótárat, és szökje meg a `()":&|!^~*?` karaktereket a keresés végrehajtása előtt. + +## Mi az a „kérdezési teljesítmény javítása”? +A kérdezési teljesítmény javítása azt jelenti, hogy csökkentjük a keresési kérésnek az indexen keresztül történő áthaladásához, a kifejezések egyezéséhez és az eredmények visszaadásához szükséges időt. Az index helyes konfigurálásával és a konfigurációnak megfelelő lekérdezések előkészítésével elkerülhetők a felesleges feldolgozások, és gyorsabb válaszidőket érhetünk el. + +## Miért használja a GroupDocs.Search Java‑t nagy teljesítményű keresésekhez? +- **Skálázható indexelés** – Millió dokumentumot kezel inkrementális frissítésekkel. +- **Gazdag nyelvi támogatás** – Beépített elemzők számos ábécéhez és speciális karakterhez. +- **Könnyű integráció** – Bármely Java‑alapú alkalmazással működik, a Spring Boot szolgáltatásoktól a asztali eszközökig. + +## Előfeltételek + +Mielőtt belemerülne, győződjön meg róla, hogy a következőkkel rendelkezik: + +### Szükséges könyvtárak és függőségek +A GroupDocs.Search Maven‑projektbe való beillesztéséhez adja hozzá az alábbi konfigurációkat: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Környezet beállítása +- JDK 8 vagy újabb telepítve és konfigurálva. +- IDE, például IntelliJ IDEA vagy Eclipse. + +### Tudás‑előfeltételek +- Alapvető Java programozás. +- Maven ismerete. +- Dokumentumkezelési koncepciók megértése. + +## A GroupDocs.Search for Java beállítása + +### 1. Telepítés Maven‑nel vagy közvetlen letöltéssel +Adja hozzá a fenti XML‑kódrészletet a `pom.xml` fájlhoz. Ha manuális megközelítést részesít előnyben, töltse le a könyvtárat a hivatalos oldalról: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### 2. Licenc beszerzése +Ingyenes próba vagy ideiglenes licenc igényelhető itt: + +[GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license) + +### 3. Alapvető inicializálás +Hozzon létre egy `Index` objektumot, amely egy mappára mutat, ahol az indexfájlok tárolódnak: + +```java +import com.groupdocs.search.*; + +public class SearchInitialization { + public static void main(String[] args) { + Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); + System.out.println("GroupDocs.Search initialized successfully."); + } +} +``` + +## Implementációs útmutató + +### Index létrehozása és konfigurálása +Az ábécé‑szótár konfigurálása lehetővé teszi, hogy meghatározza, hogyan kezelje a speciális karaktereket, ami elengedhetetlen a **kérdezési teljesítmény javításához**. + +#### 1. lépés: Index inicializálása +```java +Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); +``` + +#### 2. lépés: Karaktertípusok konfigurálása +```java +index.getDictionaries().getAlphabet() + .setRange(new char[] {'&'}, CharacterType.Letter) + .setRange(new char[] {'-'}, CharacterType.Separator); +``` +Az `&` betűként, a `-` pedig elválasztóként való kezelése biztosítja, hogy a keresőmotor a lekérdezést a kívánt módon értelmezze. + +### Dokumentumok indexelése +Most **adjon dokumentumokat az indexhez**, hogy azok kereshetők legyenek. + +#### 3. lépés: Dokumentumok hozzáadása +```java +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` +A metódus rekurzívan beolvassa a megadott mappát, és minden támogatott fájltípusra indexet hoz létre. + +### A keresési lekérdezés előkészítése +A **speciális karakterek lekérdezésben való szökéséhez** először normalizáljuk a bemenetet az ábécé‑konfiguráció alapján, majd hozzáadjuk a szökés‑szekvenciákat. + +#### 4. lépés: Speciális karakterek módosítása +```java +StringBuilder result = new StringBuilder(); +String word = "rock&roll-music"; + +for (int i = 0; i < word.length(); i++) { + char character = word.charAt(i); + CharacterType characterType = index.getDictionaries().getAlphabet().getCharacterType(character); + + if (characterType == CharacterType.Separator) { + result.append(' '); + } else { + result.append(character); + } +} +``` + +#### 5. lépés: Speciális karakterek szökése +```java +String specialCharacters = "()\":&|!^~*?"; +for (int i = result.length() - 1; i >= 0; i--) { + char c = result.charAt(i); + if (specialCharacters.indexOf(c) != -1) { + result.insert(i, '\\'); + } +} +String query = result.toString(); +if (query.contains(" ")) { + query = "\"" + query + "\""; +} +``` +A szökés megakadályozza, hogy a parser a szimbólumokat operátorként értelmezze. + +### A keresés végrehajtása +Végül futtassa a lekérdezést a felkészített indexen. + +#### 6. lépés: Keresés végrehajtása +```java +import com.groupdocs.search.results.*; + +SearchResult searchResult = index.search(query); +``` +A `search` metódus egy `SearchResult` objektumot ad vissza, amely tartalmazza a megtalált dokumentumokat, kivonatokat és a relevancia‑pontszámokat. + +## Gyakorlati alkalmazások + +### Esettanulmány 1: Dokumentumkezelő rendszerek +Ügyvédi irodák gyorsan megtalálhatják az ügyirataikat PDF‑ek, Word‑dokumentumok és e‑mailek indexelésével. A **kérdezési teljesítmény javításával** a jogászok kevesebb időt töltenek az eredmények várásával, és több időt a tartalom áttekintésével. + +### Esettanulmány 2: E‑kereskedelmi platformok +Online kereskedők termékleírásokat, specifikációkat és véleményeket indexelnek. A megfelelően szökött lekérdezések lehetővé teszik, hogy a vásárlók például a `4‑K TV` kifejezést hibák nélkül keressék, míg a gyors kérdezés zökkenőmentessé teszi a vásárlási élményt. + +## Teljesítmény‑szempontok és tippek + +- **Frissítse az indexet** tömeges importálás vagy nagyobb módosítások után, hogy alacsony maradjon a keresési késleltetés. +- **Rendelkezzen elegendő heap memóriával** (`-Xmx2g` vagy nagyobb) nagy adathalmazok esetén. +- **Használja újra az `Index` példányt** több kereséshez, ahelyett, hogy minden alkalommal újra létrehozná. +- **Profilozza a lekérdezés végrehajtását** a Java beépített eszközeivel, hogy azonosítsa a szűk keresztmetszeteket. + +## Gyakori hibák és megoldások + +| Probléma | Miért fordul elő | Megoldás | +|----------|------------------|----------| +| A lekérdezések nem adnak eredményt új fájlok hozzáadása után | Az index nem frissült | Hívja meg a `index.add(newPath)`‑t vagy építse újra az indexet. | +| Váratlan karakterekkel kapcsolatos hibák | A speciális karakterek nincsenek szökve | Győződjön meg róla, hogy az 5. lépésben szereplő szökés‑logika lefut a keresés előtt. | +| Magas memóriahasználat | Nagy eredményhalmazok egyszerre betöltése | Iteráljon lazán a `searchResult.getDocuments()`‑on, vagy korlátozza az eredményeket a `index.search(query, 100)`‑mal. | + +## Gyakran feltett kérdések + +**Q: Hogyan kezeljem a rendkívül nagy adatállományokat a GroupDocs.Search‑szal?** +A: Használjon inkrementális indexelést (`index.add`) és ütemezzen rendszeres index‑optimalizálásokat. Az index SSD‑re telepítése gyorsabb I/O‑t biztosít. + +**Q: Integrálható a GroupDocs.Search Spring Boot‑dal?** +A: Igen. Definiálja az `Index` bean‑t egy `@Configuration` osztályban, és injektálja ahol csak szükség van keresési funkcióra. + +**Q: Mely karaktereket kell szökni egy lekérdezésben?** +A: A `()":&|!^~*?` karakterek előtt `\`‑t kell elhelyezni, hogy literálként legyenek kezelve. + +**Q: Hogyan frissíthetem a meglévő indexet újonnan feltöltött dokumentumokkal?** +A: Hívja meg a `index.add("NEW_DOCUMENT_DIRECTORY")`‑t; a könyvtár új bejegyzéseket egyesíti anélkül, hogy az egész indexet újraépítené. + +**Q: Alkalmas a GroupDocs.Search valós‑idő keresési forgatókönyvekre?** +A: Teljes mértékben. A könyvtár gyors inkrementális frissítéseket és alacsony késleltetésű lekérdezéseket támogat, így ideális élő keresődobozokhoz. + +## Források +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/) + +--- + +**Utoljára frissítve:** 2026-01-21 +**Tesztelt verzió:** GroupDocs.Search Java 25.4 +**Szerző:** GroupDocs + +--- \ No newline at end of file diff --git a/content/hungarian/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/hungarian/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..4dfe5fbd --- /dev/null +++ b/content/hungarian/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,182 @@ +--- +date: '2026-01-21' +description: Tanulja meg, hogyan optimalizálja a shardokat a GroupDocs.Search for + Java használatával, valamint hogyan konfigurálja a keresési hálózatot, végezzen + szöveges keresést, és kezelje a portütközéseket. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Hogyan optimalizáljuk a shard-okat a GroupDocs.Search for Java-ban: átfogó + útmutató' +type: docs +url: /hu/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +yanesés elengedhetetlen a fejlesztők és vállalkozások számára, akik nagy adatbázisokat kezelnek, vagy szeretnék egyszerűsíteni a belső dokumentumok lekérdezési folyamatait. Ha kíváncsi vagy **hogyan optimalizáljuk a shard-eket**, ez az útmutató végigvezet a teljesítmény javításának lépésein, a keresési hálózat konfigurálásán és a gyakori kihívások, például a portütközések kezelésén. **GroupDocs.Search Java** zökkenőmentes konfigurációt és optimalizálást biztosít a keresési hálózatodhoz, javítva ezzel a teljesítményt és a felhasználói élményt. + +## Gyors válaszok +- **Mi a shard optimaliz- **ges keresést?** Használd a `TextSearchInNetwork.searchAll` metódust a lekérdezésed sztringjével. +- **Hogyan indexeljünk dokumentumokat Java-ban?** Adj hozzá dokumentumköny portütközéseket?** Módosítsd a `basePort` változót egy szabad portra a gépeden. + +## Hogyan konfiguráljuk a keresési hálóésbe és keresésbe merülnél, szilárd hálózati alapra van szükséged. Ez a szakasz bemutatja a hálózat beállításának lépéseit, a port kiválasztását, és a gyakori portütközések elkerülését. + +## Hogyan indexeljünk dokumentumokat Java-ban +Miután a hálózat működik, a következő lépés a tartalom betáplálása. Megmutatjukát, hogy a motor kereshető indexet építhessen. + +## Hogyan végeja konfigurációt. Ez megakadályozza a indítási hibákat és stabilan tartja a hálózatot. + +## Előfeltételek +Mielőtt elkezdenénk, győződj meg arról, hogy a következő előfeltételek rendelkezésre állnak: + +### Szükséges könyvtárak, verziók és függőségek +A megoldás megvalósításához add hozzá a GroupDocs.Search könyvtárat Maven segítségével, a következő konfigurációt beillesztve a `pom.xml` fájlodba: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Alternatív megoldásként töltsd le a legújabb verziót a [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) oldalról. + +### Környezet beállítási követelmények +- Győződj meg arról, hogy a fejlesztői környezeted támogatja a Java-t (JDK 8 vagy újabb). +- Hozzáférés egy olyan hálózati konfigurációhoz, amely lehetővé teszi a portok használatát. + +### Tudás előfeltételek +Alapvető Java programozási ismeretek, beleértve az objektum‑orientált elveket és a kivételkezelést, hasznosak lesznek ebben az útmutatóban. + +## A GroupDocs.Search for Java beállítása +A GroupDocs.Search használatának megkezdéséhez a projektedben kövesd az alábbi lépéseket: + +1. **Add the Dependency**: Ahogy fent látható, add hozzá a szükséges Maven függőséget a projektedhez, vagy töltsd le közvetlenül a kiadások oldaláról. +2. **License Acquisition**: + - Ingyenes próba esetén a könyvtárat korlátozások nélkül használhatod, de bizonyos használati korlátokkal. + - Szerezz be egy ideiglenes licencet a teljes funkciók eléréséhez a kiértékelés során a [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/) oldalon. + - Vásárolj teljes licencet, ha a GroupDocs.Search-et a termelési környezetbe szeretnéd integrálni. +3. **Basic Initialization and Setup**: Inicializáld a konfigurációt a `Configuration` osztály segítségével, beállítva a dokumentumok alapútvonalát és egy portszámot: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Implementációs útmutató +Most nézzük meg a kulcsfontosságú funkciók implementációját a GroupDocs.Search Java segítségével. + +### Funkció: Keresési hálózat konfigurálása +**Áttekintés**: A keresési hálózat beállítása magában foglalja a dokumentumkönyvtár definiálását és egy adott porttal való konfigurálását a csomópontok közötti kommunikációhoz. + +#### 1. lépés: Dokumentumkönyvtárak és port definiálása +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### 2. lépés: Keresési hálózat konfigurálása +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Funkció: Keresési hálózati csomópontok telepítése +**Áttekintés**: Telepíts csomópontokat a dokumentumkeresések hatékony kezeléséhez a hálózatodban. + +#### 1. lépés: Csomópontok telepítése a konfigurációval +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Funkció: Hálózati csomópont eseményekre feliratkozás +**Áttekintés**: Figyeld a keresési hálózatodat az eseményekre való feliratkozással, amelyek fontos változásokról vagy műveletekről értesítenek. + +#### 1. lépés: Feliratkozás a master csomópont eseményeire +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Funkció: Dokumentumok indexelése a hálózati csomópontokban +**Áttekintés**: Adj hozzá könyvtárakat, amelyek dokumentumokat tartalmaznak, az indexelési folyamathoz a hatékony keresés érdekében. + +#### 1. lépés: Dokumentumkönyvtárak hozzáadása az indexelési folyamathoz +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Funkció: Szöveges keresés a hálózati csomópontokban +**Áttekintés**: Szöveges keresések végrehajtása az összes indexelt dokumentumon a keresési hálózatodban. + +#### 1. lépés: Szöveges keresés végrehajtása +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Funkció: Shard-ek optimalizálása +**Áttekintés**: Javítsd a teljesítményt a shard-ek optimalizálásával a keresési hálózati cs-eket a keresési hatékonyság javítása érdekében (itt jön képbe a **hogyan optimalizáljuk a shard-eket**): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Gyakorlati alkalmazások +A GroupDocs.Search for Java számos valós helyzetben alkalmazható: + +1. **Vállalati dokumentumkezelés**eli és hívja le az ügyiratokat avtári rendszerekkel való integrációval a gyors keresés érdekében. +5. **Tartalomkezelő rendszerek (CMS)**: Javítja a tartalom felfedezhetőségét fejlett keresési képességek révén. + +## Teljesítményfontosságú szempontok +A GroupDocs.Search implementáció optimális teljesítményének biztosításához: + +- Rendszeresen optimalizáld a shard-eket a lekése érdekében. +- Figyeld és kezeld a memóriahasználatot, különösen nagy adathalmazokkal dolgozó környezetekben. +- Kövesd a Java legjobb gyakorlatait a szemétgyűjtés és erőforrás‑kezelés terén a rendszer hatékonyságának fenntartíts be és optimalizálj egy for Java segítségével. Ezekkel a készségekkel most már képes vagy hatékony dokumentumkereséseket végrehajtani különböző alkalmazásokban, ezáltal javítva a projekt teljesítményét és a felhasználói élményt. A GroupDocs.Search képességeinek további felfedezéséhez fontold meg integrálását más rendszerekkel, vagy tekintsd át a dokumentációban elérhető további funkciókat. + +## GyIK szekció +1. **Mi a shard optimalizálás?** +, majd indítsd újra a konfigurációs folyamatot. +3. **Integrálenkkenőmentesen integrálható. +4. **Milyen gyakori problémák merülnek fel a telepítés során?** + - Gyakori problémák közé tartozik a helytelen portbeállítás és a hiányzó függőségek; ügyelj a előfeltételek pontos betartására. + +## Gyakran Ismételt Kérdések + +**Q: Hogyan befolyásolja a shard optimalizálás a lekérdezés sebességét?** +A: A shard‑ek optimalizálása tömöríti az indexet, csökkentiabb lekérdezési válaszokat eredményez. + +**Q: Biztonságos-e a ` hogy leási folyamat finomhangolásához. + +**Q: Mit tegyek, ha `IOException`-t kapok az optimalizálás során?** +A: Ellenőrizd a fájlrendszer jogosultságait, győződj meg a megfelelő lemezterületről, és hogy nincs más folyamat, amely zárolja az indexfájlokat. + +**Q: Az optimalizálás visszaállítja-e a törölt dokumentumok helyét?** +A: Igen, az optimalizáló egyesíti a szegmenseket és eltávolítja a tombstone‑okat, felszabadítva a törölt dokumentumok által elfoglalt helyet. + +**Last Updated:** 2026-01-21 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs \ No newline at end of file diff --git a/content/indonesian/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/indonesian/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..6f0f78ee --- /dev/null +++ b/content/indonesian/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,214 @@ +--- +date: '2026-01-21' +description: Pelajari cara mengoptimalkan shard menggunakan GroupDocs.Search untuk + Java serta cara mengkonfigurasi jaringan pencarian, melakukan pencarian teks, dan + menangani konflik port. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Cara Mengoptimalkan Shard di GroupDocs.Search untuk Java: Panduan Komprehensif' +type: docs +url: /id/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# Cara Mengoptimalkan Shards di GroupDocs.Search untuk Java: Panduan Komprehensif + +Pencarian dokumen yang efisien sangat penting bagi pengembang dan bisnis yang mengelola basis data besar atau yang ingin menyederhanakan proses pengambilan dokumen internal. Jika Anda bertanya-tanya **bagaimana cara mengoptimalkan shards**, panduan ini akan memandu Anda melalui langkah-langkah untuk meningkatkan kinerja, mengonfigurasi jaringan pencarian Anda, dan menangani tantangan umum seperti konflik port. **GroupDocs.Search Java** menawarkan konfigurasi dan optimisasi jaringan pencarian yang mulus, meningkatkan baik kinerja maupun pengalaman pengguna. + +## Jawaban Cepat +- **What is shard optimization?** Ini mengatur ulang data indeks untuk mempercepat kueri dan mengurangi beban penyimpanan. +- **How to configure a search network?** Tentukan direktori dasar dan port, lalu deploy node menggunakan API yang disediakan. +- **How to perform text search?** Gunakan `TextSearchInNetwork.searchAll` dengan string kueri Anda. +- **How to index documents in Java?** Tambahkan direktori dokumen ke node master dengan `IndexingDocuments.addDirectories`. +- **How to handle port conflicts?** Ubah variabel `basePort` ke port yang tidak digunakan pada mesin Anda. + +## Cara Mengonfigurasi Jaringan Pencarian +Sebelum menyelami proses pengindeksan dan pencarian, Anda memerlukan fondasi jaringan yang solid. Bagian ini menjelaskan langkah-langkah untuk menyiapkan jaringan, memilih port, dan menghindari masalah konflik port yang umum. + +## Cara Mengindeks Dokumen di Java +Setelah jaringan aktif, langkah selanjutnya adalah mengisinya dengan konten. Kami akan menunjukkan cara menambahkan beberapa folder dokumen sehingga mesin dapat membangun indeks yang dapat dicari. + +## Cara Melakukan Pencarian Teks +Setelah pengindeksan, Anda ingin mengambil informasi dengan cepat. Bagian ini menunjukkan cara paling sederhana untuk menjalankan kueri teks di semua node. + +## Cara Menangani Konflik Port +Jika port default (`49132`) sudah digunakan, cukup ubah nilai `basePort` ke port yang bebas dan restart konfigurasi. Ini mencegah kesalahan saat memulai dan menjaga jaringan Anda tetap stabil. + +## Prasyarat +Sebelum kita mulai, pastikan Anda memiliki prasyarat berikut: + +### Perpustakaan, Versi, dan Dependensi yang Diperlukan +Untuk mengimplementasikan solusi ini, sertakan perpustakaan GroupDocs.Search menggunakan Maven dengan menambahkan konfigurasi berikut ke file `pom.xml` Anda: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Atau, unduh versi terbaru dari [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Persyaratan Penyiapan Lingkungan +- Pastikan lingkungan pengembangan Anda mendukung Java (JDK 8 atau lebih baru). +- Akses ke konfigurasi jaringan yang memungkinkan penggunaan port. + +### Prasyarat Pengetahuan +Pemahaman dasar tentang pemrograman Java, termasuk prinsip berorientasi objek dan penanganan pengecualian, akan sangat membantu untuk tutorial ini. + +## Menyiapkan GroupDocs.Search untuk Java +Untuk mulai menggunakan GroupDocs.Search dalam proyek Anda, ikuti langkah-langkah berikut: + +1. **Add the Dependency**: Seperti yang ditunjukkan di atas, tambahkan dependensi Maven yang diperlukan ke proyek Anda atau unduh langsung dari halaman rilis. + +2. **License Acquisition**: + - Untuk percobaan gratis, gunakan perpustakaan tanpa pembatasan fitur tetapi dengan beberapa batasan penggunaan. + - Dapatkan lisensi sementara untuk akses penuh fitur selama evaluasi dengan mengunjungi [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/). + - Beli lisensi penuh jika Anda memutuskan mengintegrasikan GroupDocs.Search ke lingkungan produksi Anda. + +3. **Basic Initialization and Setup**: Inisialisasi konfigurasi menggunakan kelas `Configuration`, mengatur jalur dasar untuk dokumen dan menentukan nomor port: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Panduan Implementasi +Sekarang mari kita jelajahi implementasi fitur utama menggunakan GroupDocs.Search Java. + +### Fitur: Mengonfigurasi Jaringan Pencarian +**Overview**: Menyiapkan jaringan pencarian melibatkan penentuan direktori dokumen Anda dan mengkonfigurasinya dengan port tertentu untuk komunikasi antar node. + +#### Langkah 1: Tentukan Direktori Dokumen dan Port +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Langkah 2: Konfigurasikan Jaringan Pencarian +Buat objek konfigurasi menggunakan jalur yang telah ditentukan: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Fitur: Menyebarkan Node Jaringan Pencarian +**Overview**: Menyebarkan node untuk menangani pencarian dokumen secara efisien di seluruh jaringan Anda. + +#### Langkah 1: Menyebarkan Node Menggunakan Konfigurasi +Sebarkan node jaringan pencarian dan identifikasi node master untuk manajemen terpusat: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Fitur: Berlangganan ke Event Node Jaringan +**Overview**: Pantau jaringan pencarian Anda dengan berlangganan ke event yang memberi tahu Anda tentang perubahan atau tindakan penting. + +#### Langkah 1: Berlangganan ke Event Node Master +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Fitur: Mengindeks Dokumen di Node Jaringan +**Overview**: Tambahkan direktori yang berisi dokumen ke proses pengindeksan untuk pencarian yang efisien. + +#### Langkah 1: Tambahkan Direktori Dokumen ke Proses Pengindeksan +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Fitur: Pencarian Teks di Node Jaringan +**Overview**: Jalankan pencarian teks di semua dokumen yang diindeks dalam jaringan pencarian Anda. + +#### Langkah 1: Lakukan Pencarian Teks +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Fitur: Mengoptimalkan Shards +**Overview**: Tingkatkan kinerja dengan mengoptimalkan shards dalam indeks pada node jaringan pencarian Anda. + +#### Langkah 1: Optimalkan Shards pada Indexer +Optimalkan shards untuk meningkatkan efisiensi pencarian (di sinilah **bagaimana cara mengoptimalkan shards** menjadi penting): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Aplikasi Praktis +GroupDocs.Search untuk Java dapat diterapkan dalam berbagai skenario dunia nyata: + +1. **Enterprise Document Management**: Memfasilitasi pengambilan dokumen di seluruh basis data perusahaan yang besar. +2. **E‑commerce Platforms**: Meningkatkan kemampuan pencarian produk dengan menggunakan pengindeksan dan fitur kueri yang dioptimalkan. +3. **Legal Firms**: Mengelola dan mengambil file kasus serta dokumen dari arsip yang luas secara efisien. +4. **Library Systems**: Menyederhanakan proses katalog dengan mengintegrasikan sistem perpustakaan digital untuk pencarian cepat. +5. **Content Management Systems (CMS)**: Meningkatkan penemuan konten melalui kemampuan pencarian lanjutan. + +## Pertimbangan Kinerja +Untuk memastikan kinerja optimal dari implementasi GroupDocs.Search Anda: +- Secara rutin optimalkan shards untuk mengurangi waktu respons kueri. +- Pantau dan kelola penggunaan memori, terutama di lingkungan yang menangani dataset besar. +- Ikuti praktik terbaik Java untuk pengumpulan sampah (garbage collection) dan manajemen sumber daya guna mempertahankan efisiensi sistem. + +## Kesimpulan +Dengan mengikuti panduan komprehensif ini, Anda telah mempelajari cara menyiapkan dan mengoptimalkan jaringan pencarian menggunakan GroupDocs.Search untuk Java. Dengan keterampilan ini, Anda kini siap menangani pencarian dokumen yang efisien di berbagai aplikasi, meningkatkan kinerja proyek dan pengalaman pengguna. Untuk lebih mengeksplorasi kemampuan GroupDocs.Search, pertimbangkan mengintegrasikannya dengan sistem lain atau menjelajahi fitur tambahan yang tersedia dalam dokumentasi mereka. + +## Bagian FAQ +- **What is shard optimization?** + - Optimasi shard meningkatkan kinerja jaringan pencarian dengan mengatur data lebih efisien di setiap shard. +- **How do I handle port conflicts when configuring a search network?** + - Ubah variabel basePort ke port yang tidak digunakan pada sistem Anda dan restart proses konfigurasi. +- **Can GroupDocs.Search be integrated with existing Java applications?** + - Ya, dapat diintegrasikan secara mulus dengan menyertakan dependensi perpustakaan dalam proyek Anda. +- **What are some common issues faced during setup?** + - Masalah umum meliputi konfigurasi port yang salah dan dependensi yang hilang; pastikan Anda mengikuti prasyarat dengan tepat. + +## Pertanyaan yang Sering Diajukan + +**Q: How does shard optimization affect query speed?** +A: Optimizing shards memadatkan indeks, mengurangi I/O disk, dan biasanya menghasilkan respons kueri yang lebih cepat. + +**Q: Is it safe to run `optimizeShards` on a live node?** +A: Ya, operasi ini dirancang untuk berjalan tanpa downtime, tetapi sebaiknya dijadwalkan pada periode lalu lintas rendah untuk indeks yang besar. + +**Q: Can I customize the `OptimizeOptions`?** +A: Tentu saja. Anda dapat mengatur parameter seperti `maxSegmentSize` atau `mergeFactor` untuk menyesuaikan proses optimisasi. + +**Q: What should I do if I encounter an `IOException` during optimization?** +A: Verifikasi izin sistem file, pastikan ruang disk cukup, dan pastikan tidak ada proses lain yang mengunci file indeks. + +**Q: Does optimizing shards also reclaim deleted document space?** +A: Ya, optimizer menggabungkan segmen dan menghapus tombstone, membebaskan ruang yang ditempati dokumen yang dihapus. + +--- + +**Terakhir Diperbarui:** 2026-01-21 +**Diuji Dengan:** GroupDocs.Search 25.4 untuk Java +**Penulis:** GroupDocs \ No newline at end of file diff --git a/content/italian/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md b/content/italian/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md new file mode 100644 index 00000000..e7a4e528 --- /dev/null +++ b/content/italian/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md @@ -0,0 +1,206 @@ +--- +date: '2026-01-21' +description: Scopri come aggiungere la dipendenza GroupDocs Maven, configurare e sincronizzare + una rete di ricerca Java e aggiungere directory da indicizzare con GroupDocs.Search. +keywords: +- Java Search Network Configuration +- GroupDocs.Search for Java +- Document Indexing and Retrieval +title: Dipendenza Maven di GroupDocs – Sincronizzazione della rete di ricerca Java +type: docs +url: /it/java/search-network/java-groupdocs-search-configuration-sync-guide/ +weight: 1 +--- + + Maven di GroupDocs: Configurazione e sincronizzazione delle reti di ricerca Java + +In questa guida completa scoprirai **come aggiungere la dipendenza Maven di GroupDocs** al tuo progetto e quindi configurare una solida rete di ricerca Java utilizzando GroupDocs.Search. Che tu stia gestendo atti legali, report finanziari o articoli accademici modo effic e cercare enormi collezioni di documenti è una sfida quotidiana per molte organizzazioni. Integrando la **dipendenza Maven di GroupDocs**, ottieni accesso a un potente motore di indicizzazione che scala su più nodi. Questo tutorial ti guida attraverso l'installazione della dipendenza, il deployment dei nodi di rete, l'aggiunta di directory da indicizzare e laimali. + +### Risposte rapide +- **Che cos'è la indicizzare?** Usa `IndexingDocuments.addDirectories` sul nodo master. +- **Come sincronizzare gli shard?** Chiama `SynchronizeOptions. +-uso in produzione. + +## Che cos'è la dipendenza Maven di GroupDocs? + +La dipendenza Maven di GroupDocs (`com.groupdocs:groupdocs-search`) include tutte le classi necessarie per creare indici ricercabili, gestire i nodi di rete e eseguire query rapide. Aggiungerla al tuo `pom.xml` garantisce che Maven scarichi i binari corretti e le dipendenze transitive. + +## Come aggiungere la dipendenza Maven di GroupDocs + +### Configurazione Maven + +Aggiungi il repository e la dipendenza al tuo `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +> **Consiglio:** Mantieni il numero di versione aggiornato controllando la pagina ufficiale delle release. + +Puoi anche scaricare il JAR direttamente dal sito ufficiale: [GroupDocs.Search per Java releases](https://releases.groupdocs.com/search/java/). + +## Prerequisiti + +- **JDK** (11 o superiore) installato. +- Un IDE come IntelliJ IDEA o Eclipse. +- Conoscenza di base di Java, familiarità con Maven e comprensione dei concetti di nodi di rete. +- Una licenza valida di GroupDocs.Search (trial gratuito o commerciale). + +## Inizializzazione e configurazione di base + +Inizia creando una directory di indice: + +```java +import com.groupdocs.search.SearchIndex; +import com.groupdocs.search.options.IndexingOptions; + +// Create an index in the specified directory +SearchIndex index = new SearchIndex("YOUR_INDEX_DIRECTORY"); +``` + +Questo semplice passaggio prepara l'ambiente per la successiva configurazione della rete. + +## Guida all'implementazione + +### Funzionalità 1: Configurazione della rete di ricerca + +#### Panoramica + +Configurare la rete di ricerca imposta i percorsi dei file e le porte che i nodi utilizzeranno per comunicare. + +##### Configurazione percorsi e porte +```java +import com.groupdocs.search.options.*; +import com.groupdocs.search.scaling.configuring.ConfiguringSearchNetwork; + +// Set custom paths for input/output directories +String basePath = "YOUR_DOCUMENT_DIRECTORY/AdvancedUsage/Scaling/SynchronizingShards/"; +int basePort = 49144; // Adjust if there's a port conflict + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` +L'oggetto `configuration` ora contiene tutte le impostazioni necessarie per la tua rete di ricerca. + +### Funzionalità 2: Distribuzione dei nodi della rete di ricerca + +#### Panoramica + +Distribuisci i nodi per distribuire il carico di lavoro sulla tua rete. Il nodo master gestisce le operazioni e gli eventi. + +##### Codice di distribuzione +```java +import com.groupdocs.search.scaling.*; +import com.groupdocs.search.options.Configuration; + +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +// Retrieve the master node for further operations +SearchNetworkNode masterNode = nodes[0]; +``` + +### Funzionalità 3: Sottoscrizione agli eventi dei nodi della rete di ricerca + +#### Panoramica + +Ascoltare gli eventi consente una gestione dinamica di modifiche o aggiornamenti nella tua rete. + +##### Implementazione della sottoscrizione +```java +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.scaling.SearchNetworkNodeEvents; + +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Funzionalità 4: Aggiunta di directory all'indice + +#### Panoramica + +L'aggiunta di directory è il passaggio fondamentale che rende i tuoi documenti ricercabili. + +##### Aggiunta di documenti +```java +import com.groupdocs.search.indexing.IndexingDocuments; +import com.groupdocs.search.scaling.SearchNetworkNode; + +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +``` + +### Funzionalità 5: Sincronizzazione degli shard nel nodo della rete di ricerca + +#### Panoramica + +La sincronizzazione garantisce la coerenza dei dati su tutti gli shard. + +##### Codice di sincronizzazione +```java +import com.groupdocs.search.indexing.Indexer; +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.options.SynchronizeOptions; + +SearchNetworkNode node = null; // Assume 'node' is initialized as a SearchNetworkNode + +def synchronizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + SynchronizeOptions options = new SynchronizeOptions(); + indexer.synchronize(options); +} +``` + +### Funzionalità 6: Chiusura dei nodi della rete di ricerca + +#### Panoramica + +Chiudere correttamente i nodi rilascia le risorse e previene perdite di memoria. + +##### Chiusura del nodo +```java +import com.groupdocs.search.scaling.SearchNetworkNode; + +for (SearchNetworkNode node : nodes) { + node.close(); +} +``` + +## Applicazioni pratiche + +1. **Gestione di documenti legali** – Recupera rapidamente fascicoli e precedenti. +2. **Gestione dei record finanziari** – Accedi a Monitora l'utilizzo dell' indici di grandi dimensioni. +- **Strategia di scaling** – Aggiungi nodi proporzionalmente-----------| +| I nodi non riescono a connettersi | Conflitto di porta | Modifica `basePort` con un valore non utilizzato | +| Indice non aggiornato | Sottoscrizione agli eventi mancante | Assicurati che `SearchNetworkNodeEvents.subscribe(masterNode)` sia chiamato | +| Elevata latenza | Sh bilancia la distribuzione dei documenti | + +## Domande frequenti + +**Q: Qual è il beneficio principale dell'utilizzo di GroupDocs.Search?** +A: Fornisce capacità di ricerca rapide e scalabili su grandi insiemi di documenti con configurazione minima. + +**Q: Posso personalizzare le configurazioni dei nodi in una rete di ricerca?** +A: Sì, è possibile impostare percorsi, porte e altre opzioni personalizzate tramite l'oggetto `Configuration`. + +**Q: Come aggiungo directory all'indice dopo che la rete è in esecuzione?** +A: Chiama `IndexingDocuments.addDirectories(masterNode, "path")` ogni volta che devi indicizzare nuove cartelle. + +**Q: Come sincronizzare gli shard quando un nuovo nodo si unisce alla rete?** +A: Usa il metodo `synchronizeShards` mostrato sopra sul nodo appena aggiunto. + +**Q: È necessaria una licenza per lo sviluppo?** +A: Una licenza di prova gratuita è sufficiente per i test; è richiesta una lic passaggi costituiscono la base per una soluzione di ricerca documenti ad alte prestazioni che può crescere con le esigenze della tua organizzazione. + +--- + +**Ultimo aggiornamento:** \ No newline at end of file diff --git a/content/italian/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/italian/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..0ce18386 --- /dev/null +++ b/content/italian/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,197 @@ +--- +date: '2026-01-21' +description: Scopri come ottimizzare gli shard utilizzando GroupDocs.Search per Java + e come configurare la rete di ricerca, eseguire ricerche testuali e gestire i conflitti + di porta. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Come ottimizzare gli shard in GroupDocs.Search per Java: una guida completa' +type: docs +url: /it/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# Come ottimizzare gli shard in GroupDocs.Search per Java: Guida completa + +La ricerca efficiente di documenti è essenziale per sviluppatori e aziende che gestiscono grandi database o che desiderano semplificare i processi di recupero interno dei documenti. Se ti chiedi **come ottimizzare gli shard**, questa guida ti accompagnerà passo passo per migliorare le prestazioni, configurare la tua rete di ricerca e gestire le sfide comuni come i conflitti di porta. **GroupDocs.Search Java** offre una configurazione e un'ottimizzazione senza soluzione di continuità della tua rete di ricerca, migliorando sia le prestazioni sia l'esperienza dell'utente. + +## Risposte rapide +- **Cos'è l'ottimizzazione degli shard?** Riorganizza i dati dell'indice per velocizzare le query e ridurre l'overhead di archiviazione. +- **Come configurare una rete di ricerca?** Definisci una directory di base e una porta, quindi distribuisci i nodi usando l'API fornita. +- **Come eseguire una ricerca testuale?** Usa non utilizzata sulla tua macchina. + +## Come configur immergerti nell'indicizzazione, scegliere una porta e evitare i comuni problemi di conflitto di porta. + +## Come indicizzare i documenti in Java +Una volta che la rete è attiva, il passo successivo è alimentarla con contenuti. Ti mostreremo come aggiungere più cartelle di documenti affinché il motore possa costruire eseguire una ricerca testuale +Dopo l'indicizzazione, vorrai recuperare le informazioni rapidamente. Questa sezione dimostra il modo più semplice per eseguire una query testuale su tutti i nodi. + +## Come gestire i conflitti di porta +Se la porta predefinita (`49132`) è già in uso, basta cambiare il valore di `basePort` con una porta libera e riavviare la configurazione. Questo previene errori di avvio e mantiene stabile la tua rete. + +## Prerequisiti +Prima di iniziare, assicurati di avere i seguenti prerequisiti in ordine: + +### Librerie richieste, versioni e dipendenze +Per implementare questa soluzione, includi la libreria GroupDocs.Search usando Maven aggiungendo la seguente configurazione al tuo file `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` +In alternativa, scarica l'ultima versione da [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Requisiti di configurazione dell'ambiente +- Assicurati che il tuo ambiente di sviluppo supporti Java (JDK 8 o successivo). +- Accesso a una configurazione di rete che consenta l'uso delle porte. + +### Prerequisiti di conoscenza +Una comprensione di base della programmazione Java, inclusi i principi orientati agli oggetti e la gestione delle eccezioni, sarà utile per questo tutorial. + +## Configurare GroupDocs.Search per Java +Per iniziare a usare GroupDocs.Search nel tuo progetto, segui questi passaggi: + +1. **Aggiungi la dipendenza**: Come mostrato sopra, aggiungi la dipendenza Maven necessaria al tuo progetto o scaricala direttamente dalla pagina dei rilasci. +2. **Acquisizione della licenza**: + - Per una prova gratuita, usa la libreria senza restrizioni sulle funzionalità ma con alcune limitazioni di utilizzo. + - Ottieni una licenza temporanea per l'accesso completo alle funzionalità durante la valutazione visitando [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/). + - Acquista una licenza completa se decidi di integrare GroupDocs.Search nel tuo ambiente di produzione. +3. **Inizializzazione e configurazione di base**: Inizializza la configurazione usando la classe `Configuration`, impostando il percorso base per i documenti e specificando un numero di porta: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Guida all'implementazione +Ora esploriamo l'implementazione delle funzionalità chiave usando GroupDocs.Search Java. + +### Funzionalità: Configurare la rete di ricerca +**Panoramica**: Configurare una rete di ricerca comporta la definizione della directory dei documenti e la sua configurazione con una porta specifica per la comunicazione tra i nodi. + +#### Passo 1: Definire le directory dei documenti e la porta +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Passo 2: Configurare la rete di ricerca +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Funzionalità: Distribuire i nodi della rete di ricerca +**Panoramica**: Distribuire i nodi per gestire le ricerche di documenti in modo efficiente nella tua rete. + +#### Passo 1: Distribuire i nodi usando la configurazione +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Funzionalità: Sottoscrivere gli eventi dei nodi di rete +**Panoramica**: Monitora la tua rete di ricerca sottoscrivendo gli eventi che ti notificano cambiamenti o azioni importanti. + +#### Passo 1: Sottoscrivere gli eventi del nodo master +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Funzionalità: Indicizzare i documenti nei nodi di rete +**Panoramica**: Aggiungi le directory contenenti documenti al processo di indicizzazione per ricerche efficienti. + +#### Passo 1: Aggiungere le directory dei documenti al processo di indicizzazione +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Funzionalità: Ricerca testuale nei nodi di rete +**Panoramica**: Eseguire ricerche testuali su tutti i documenti indicizzati all'interno della tua rete di ricerca. + +#### Passo 1: Eseguire una ricerca testuale +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Funzionalità: Ottimizzare gli shard +**Panoramica**: Migliorare le prestazioni ottimizzando gli shard all'interno dell'indicizzatore del nodo della tua rete di ricerca. + +#### Passo 1: Ottimizzare gli shard dell'indicizzatore +Ottimizza gli shard per migliorare l'efficienza della ricerca (qui è dove **come ottimizzare gli shard** è davvero importante): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Applicazioni pratiche +GroupDocs.Search per Java può essere applicato in vari scenari reali: + +1. **Gestione documentale aziendale**: Facilitare il recupero dei documenti su grandi database aziendali. +2. **Piattaforme e‑commerce**: Potenziare le capacità di ricerca dei prodotti usando funzionalità di indicizzazione e query ottimizzate. +3. **Studi legali**: Gestire e recuperare efficientemente fascicoli e documenti da archivi estesi. +4. **Sistemi bibliotecari**: Semplificare il processo di catalogazione integrandosi con sistemi di biblioteca digitale per ricerche rapide. +5. **Sistemi di gestione dei contenuti (CMS)**: Migliorare la scoperta dei contenuti attraverso capacità di ricerca avanzate. + +## Considerazioni sulle prestazioni +Per garantire prestazioni ottimali della tua implementazione di GroupDocs.Search: + +- Ottimizza regolarmente gli shard per ridurre i tempi di risposta delle query. +- Monitora e gestisci l'uso della memoria, soprattutto in ambienti che gestiscono grandi set di dati. +- Segui le migliori pratiche Java per la garbage collection e la gestione delle risorse per mantenere l'efficienza del sistema. + +## Conclusione +Seguendo questa guida completa, hai imparato come configurare e ottimizzare una rete di ricerca usando GroupDocs.Search per Java. Con queste competenze, sei ora pronto a gestire ricerche documentali efficienti in varie applicazioni, migliorando le prestazioni del tuo progetto e l'esperienza dell'utente. Per approfondire ulteriormente le capacità di GroupDocs.Search, considera di integrarlo con altri sistemi o di esplorare le funzionalità aggiuntive disponibili nella loro documentazione. + +## Sezione FAQ +1. **Cos'è l'ottimizzazione degli shard?** + - L'ottimizzazione degli shard migliora le prestazioni della rete di ricerca organizzando i dati in modo più efficiente all'interno di ogni shard. +2. **Come gestisco i conflitti di porta durante la configurazione di una rete di ricerca?** + - Cambia la variabile basePort con una porta non utilizzata sul tuo sistema e riavvia il processo di configurazione. +3. **GroupDocs.Search può essere integrato con applicazioni Java esistenti?** + - Sì, può essere integrato senza problemi includendo la dipendenza della libreria nel tuo progetto. +4. **Quali sono alcuni problemiazione?** + - I problemi comuni includono configurazioni di porta errate e dipendenze mancanti; assicurati di segu shard sulla velocità delle query?** +R: L'ottimizzazione degli shard compatta l'indice, riduce l'I/O su disco e tipicamente produce risposte sicuro eseguire `optimizeShards` su un nodo attivo?** +R: Sì, l'operazione è progettata per funzionare senza tempi di inattività, ma è consigliabile programmarla durante periodi di basso traffico per indici di grandi dimensioni. + +**D: Posso personalizzare `OptimizeOptions`?** +R: Assolutamente. Puoi impostare parametri come `maxSegmentSize` o `mergeFactor` per perfezionare il processo di ottimizzazione. + +**D: Cosa devo fare se incontro un `IOException` durante l'ottimizzazione?** +R: Verifica i permessi del file system, assicurati di avere spazio su disco sufficiente e conferma che nessun altro processo stia bloccando i file dell'indice. + +**D: L'ottimizzazione degli shard recupera anche lo spazio dei documenti eliminati?** +R: Sì, l'ottimizzatore unisce i segmenti e rimuove i tombstone, liberando lo spazio occupato dai documenti cancellati. + +--- + +**Ultimo aggiornamento:** 2026-01-21 +**Testato con:** GroupDocs.Search 25.4 for Java +**Autore \ No newline at end of file diff --git a/content/japanese/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/japanese/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md new file mode 100644 index 00000000..109e7f53 --- /dev/null +++ b/content/japanese/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -0,0 +1,194 @@ +--- +date: '2026-01-21' +description: GroupDocs.Search Java を使用して、特殊文字を正しくエスケープしながらクエリのパフォーマンスを向上させ、ドキュメントをインデックスに追加する方法を学びましょう。 +keywords: +- GroupDocs.Search Java +- document index optimization +- search query performance +title: GroupDocs.Search Javaでクエリ性能を向上させる：インデックスと検索の最適化 +type: docs +url: /ja/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/ +weight: 1 +--- + +# Improve Query Performance with GroupDocs.Search Java: Optimize Index & Search + +大量のドキュメントを効率的に管理するには、**クエリパフォーマンスの向上**から始めます。このチュートリアルでは、高性能インデックスの作成と設定できるのエス the main goal?** Improve query performance by fine‑tuning the index and query handling. +- **Which library is used?** GroupDocs.Search for Java. +- **Do I need a license?** A free trial or temporary license is sufficient for development; a full license is required for production. +- **How do I add documents?** Use `index.add("YOUR_DOCUMENT_DIRECTORY")` **How are special characters handled?** Configure What is “improve query performance”? +Improving query performance means reducing the time it takes for a search request to travel through the index, match terms, and return results. By configuring the index correctly and preparing queries that align with that configuration, you eliminate unnecessary processing and achieve faster response times. + +## Why use GroupDocs.Search Java for high‑performance searches? +- **Scalable indexing** – Handles millions use GroupDocs.Search in a Maven project, include the following configurations: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Environment Setup +- JDK 8 or newer installed and configured. +- IDE such as IntelliJ IDEA or Eclipse. + +### Knowledge Prerequisites +- Basic Java programming. +- Familiarity with Maven. +- Understanding of document management concepts. + +## Setting Up GroupDocs.Search for Java + +### 1. Install via Maven or Direct Download +Add the XML snippet above to your `pom.xml`. If you prefer a manual approach, download the library from the official site: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### 2. Acquire a License +You can obtain a free trial or a temporary license here: + +[GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license) + +### 3. Basic Initialization +Create an `Index` object that points to a folder where the index files will be stored: + +```java +import com.groupdocs.search.*; + +public class SearchInitialization { + public static void main(String[] args) { + Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); + System.out.println("GroupDocs.Search initialized successfully."); + } +} +``` + +## Implementation Guide + +### Creating and Configuring an Index +Configuring the alphabet dictionary lets you decide how special characters are treated, which is essential for **improve query performance**. + +#### Step 1: Initialize Index +```java +Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); +``` + +#### Step 2: Configure Character Types +```java +index.getDictionaries().getAlphabet() + .setRange(new char[] {'&'}, CharacterType.Letter) + .setRange(new char[] {'-'}, CharacterType.Separator); +``` +Treating `&` as a letter and `-` as a separator ensures the search engine parses queries the way you expect. + +### Indexing Documents +Now let’s **add documents to index** so they become searchable. + +#### Step 3: Adding Documents +```java +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` +The method scans the specified folder recursively and indexes every supported file type. + +### Preparing the Search Query +To **escape special characters query**, we first normalize the input based on the alphabet configuration, then add escape sequences. + +#### Step 4: Modify Special Characters +```java +StringBuilder result = new StringBuilder(); +String word = "rock&roll-music"; + +for (int i = 0; i < word.length(); i++) { + char character = word.charAt(i); + CharacterType characterType = index.getDictionaries().getAlphabet().getCharacterType(character); + + if (characterType == CharacterType.Separator) { + result.append(' '); + } else { + result.append(character); + } +} +``` + +#### Step 5: Escape Special Characters +```java +String specialCharacters = "()\":&|!^~*?"; +for (int i = result.length() - 1; i >= 0; i--) { + char c = result.charAt(i); + if (specialCharacters.indexOf(c) != -1) { + result.insert(i, '\\'); + } +} +String query = result.toString(); +if (query.contains(" ")) { + query = "\"" + query + "\""; +} +``` +Escaping prevents the parser from misinterpreting symbols as operators. + +### Executing the Search +Finally, run the query against the prepared index. + +#### Step 6: Execute Search +```java +import com.groupdocs.search.results.*; + +SearchResult searchResult = index.search(query); +``` +The `search` method returns a `SearchResult` object containing matched documents, snippets, and relevance scores. + +## Practical Applications + +### Case Study 1: Document Management Systems +Law firms can quickly locate case files by indexing PDFs, Word documents, and emails. By **improving query performance**, attorneys spend less time waiting for results and more time reviewing content. + +### Case Study 2: E‑commerce Platforms +Online retailers index product descriptions, specifications, and reviews. Properly escaped queries allow customers to search for phrases like `4‑K TV` without errors, while fast query execution keeps the shopping experience smooth. + +## Performance Considerations & Tips + +- **Refresh the index** after bulk imports or large updates to keep search latency low. +- **Allocate sufficient heap memory** (`-Xmx2g` or higher) for large data sets. +- **Reuse the `Index` instance** across multiple searches instead of recreating it each time. +-in tools to identify bottlenecks. + +## Common Pitfalls & Solutions + +| Issue | Why it Happens | Fix | +|-------|----------------|-----| +| Queries return no results after adding new files | Index not updated | Call `index.add(newPath)` or rebuild the index. | +| Errors indexing (`index + a `@Configuration` class and inject it wherever you need search capabilities. + +**Q: Which characters must be escaped in a query?** +A: The characters `()":&|!^~*?` need a preceding backslash (`\`) to be treated as literals. + +**Q: How can I update an existing index with newly uploaded documents?** +A: Call `index.add("NEW_DOCUMENT_DIRECTORY")`; the library will merge new entries without rebuilding the whole index. + +**Q: Is GroupDocs.Search suitable for real‑time search scenarios?** +A: Absolutely. The library supports fast incremental updates and low‑latency queries, making it ideal for live search boxes. + +## Resources +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/) + +--- + +**Last Updated:** 2026-01-21 +**Tested With:** GroupDocs.Search Java 25.4 +**Author:** GroupDocs + +--- \ No newline at end of file diff --git a/content/japanese/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md b/content/japanese/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md new file mode 100644 index 00000000..f27475fe --- /dev/null +++ b/content/japanese/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md @@ -0,0 +1,230 @@ +--- +date: '2026-01-21' +description: GroupDocs Maven 依存関係の追加方法、Java 検索ネットワークの構成と同期、そして GroupDocs.Search を使用してインデックス対象ディレクトリを追加する方法を学びましょう。 +keywords: +- Java Search Network Configuration +- GroupDocs.Search for Java +- Document Indexing and Retrieval +title: GroupDocs Maven 依存関係 – Java 検索 ネットワーク同期 +type: docs +url: /ja/java/search-network/java-groupdocs-search-configuration-sync-guide/ +weight: 1 +--- + +# GroupDocs Maven 依存関係: Java 検索ネットワークの構成と同期 + +この包括的なガイドでは、**GroupDocs Maven 依存関係をプロジェクトに追加**し、GroupDocs.Search を使用して堅牢な Java 検索ネットワークを構成する方法を紹介します。法務文書、財務レポート、学術論文を扱う場合でも、以下の手順でインデックス作成、検索、シャードの同期を効率的に行うことができます。 + +## Introduction + +膨大なドキュメントコレクションの管理と検索は、多くの組織の設定のデンスのためのシャード同期手順を順に解説します。 + +### Quick Answers +- **GroupDocs Maven 依存関係とは？** Maven アーティファクトで、GroupDocs.Search ライブラリを Java プロジェクトに取り込みます。 +- **検索ネットワークを使用する理由は？** インデックス作成とクエリ負荷を複数ノードに分散し、速度と信頼性を向上させます。 +- **ディレクトリをインデックスに追加する方法は？** マスターノードで `IndexingDocuments.addDirectories` を使用します。 +- **シャードを同期する方法は？** 各ノードの `Indexer` で `SynchronizeOptions` を呼び出します。 +- **ライセンスは必要ですか？** はい、商用利用にはトライアルまたは商用ライセンスが必要です。 + +## What is the GroupDocs Maven Dependency? + +GroupDocs Maven 依存関係（`com.groupdocs:groupdocs-search`）は、検索可能なインデックスの構築、ネットワークノードの管理、迅速なクエリ実行に必要なすべてのクラスをパッケージ化しています。`pom.xml` に追加することで、Maven が正しいバイナリとトランジティブ依存関係を取得します。 + +## How to Add the GroupDocs Maven Dependency + +### Maven Configuration + +`pom.xml` にリポジトリと依存関係を追加します: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +> **Pro tip:** 公式リリースページでバージョン番号を最新に保ちましょう。 + +公式サイトから JAR を直接ダウンロードすることもできます: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/)。 + +## Prerequisites + +- **JDK**（11 以上）をインストール済み +- IntelliJ IDEA や Eclipse などの IDE +- 基本的な Java 知識、Maven の経験、ネットワークノード概念の理解 +- 有効な GroupDocs.Search ライセンス（無料トライアルまたは商用） + +## Basic Initialization and Setup + +インデックスディレクトリを作成します: + +```java +import com.groupdocs.search.SearchIndex; +import com.groupdocs.search.options.IndexingOptions; + +// Create an index in the specified directory +SearchIndex index = new SearchIndex("YOUR_INDEX_DIRECTORY"); +``` + +このシンプルな手順で、以降のネットワーク構成の準備が整います。 + +## Implementation Guide + +### Feature 1: Configuration of Search Network + +#### Overview + +検索ネットワークの構成では、ノード間の通信に使用するファイルパスとポートを設定します。 + +##### Set Up Paths and Ports +```java +import com.groupdocs.search.options.*; +import com.groupdocs.search.scaling.configuring.ConfiguringSearchNetwork; + +// Set custom paths for input/output directories +String basePath = "YOUR_DOCUMENT_DIRECTORY/AdvancedUsage/Scaling/SynchronizingShards/"; +int basePort = 49144; // Adjust if there's a port conflict + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` +`configuration` オブジェクトに検索ネットワークに必要なすべての設定が格納されます。 + +### Feature 2: Deploying Search Network Nodes + +#### Overview + +ノードをデプロイしてネットワーク全体にワークロードを分散します。マスターノードが操作とイベントを管理します。 + +##### Deployment Code +```java +import com.groupdocs.search.scaling.*; +import com.groupdocs.search.options.Configuration; + +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +// Retrieve the master node for further operations +SearchNetworkNode masterNode = nodes[0]; +``` + +### Feature 3: Subscribing to Search Network Node Events + +#### Overview + +イベントをリッスンすることで、ネットワーク内の変更や更新に動的に対応できます。 + +##### Subscription Implementation +```java +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.scaling.SearchNetworkNodeEvents; + +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Feature 4: Adding Directories to Index + +#### Overview + +ディレクトリを追加することは、ドキュメントを検索可能にする核心的なステップです。 + +##### Document Addition +```java +import com.groupdocs.search.indexing.IndexingDocuments; +import com.groupdocs.search.scaling.SearchNetworkNode; + +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +``` + +### Feature 5: Synchronizing Shards in Search Network Node + +#### Overview + +同期はすべてのシャード間でデータの一貫性を保ちます。 + +##### Synchronization Code +```java +import com.groupdocs.search.indexing.Indexer; +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.options.SynchronizeOptions; + +SearchNetworkNode node = null; // Assume 'node' is initialized as a SearchNetworkNode + +def synchronizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + SynchronizeOptions options = new SynchronizeOptions(); + indexer.synchronize(options); +} +``` + +### Feature 6: Closing Search Network Nodes + +#### Overview + +ノードを適切に閉じることでリソースが解放され、メモリリークを防止します。 + +##### Node Closure +```java +import com.groupdocs.search.scaling.SearchNetworkNode; + +for (SearchNetworkNode node : nodes) { + node.close(); +} +``` + +## Practical Applications + +1. **Legal Document Management** – ケースファイルや判例を迅速に取得 +2. **Financial Record Keeping** – 明細書や監査トレイルに数秒でアクセス +3. **Academic Research** – 数千件の論文を検索し、関連する引用を見つける + +## Performance Considerations + +- **Optimize Queries** – 簡潔なクエリを書いて応答時間を短縮 +- **Memory Management** – JVM ヒープ使用量を監視し、大規模インデックス向けに GC チューニングを検討 +- **Scaling Strategy** – データ量とクエリ負荷に応じてノードを比例的に追加 + +## Common Issues and Solutions + +| Issue | Cause | Solution | +|-------|-------|----------| +| Nodes fail to connect | Port conflict | `basePort` を未使用の値に変更 | +| Index not updating | Event subscription missing | `SearchNetworkNodeEvents.subscribe(masterNode)` が呼び出されていることを確認 | +| High latency | Insufficient shards | ノード数を増やし、ドキュメント分散を調整 | + +## Frequently Asked Questions + +**Q: What is the primary benefit of using GroupDocs.Search?** +A: 大規模なドキュメントセットに対して、最小限の設定で高速かつスケーラブルな検索機能を提供します。 + +**Q: Can I customize node configurations in a search network?** +A: はい、`Configuration` オブジェクトを通じてカスタムパス、ポート、その他のオプションを設定できます。 + +**Q: How do I add directories to index after the network is running?** +A: 新しいフォルダーをインデックス化する必要があるときは、`IndexingDocuments.addDirectories(masterNode, "path")` を呼び出します。 + +**Q: How to sync shards when a new node joins the network?** +A: 上記の `synchronizeShards` メソッドを新規追加ノードで実行します。 + +**Q: Do I need a license for development?** +A: テストには無料トライアルライセンスで十分ですが、商用利用には商用ライセンスが必要です。 + +## Conclusion + +このガイドに従うことで、**GroupDocs Maven 依存関係の追加**、マルチノード検索ネットワークの構成、ディレクトリのインデックス化、シャードの同期方法を習得できました。これらの手順は、組織のニーズに合わせて拡張可能な高性能ドキュメント検索ソリューションの基盤となります。 + +--- + +**Last Updated:** 2026-01-21 +**Tested With:** GroupDocs.Search 25.4 +**Author:** GroupDocs + +--- \ No newline at end of file diff --git a/content/japanese/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/japanese/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..aea22655 --- /dev/null +++ b/content/japanese/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,206 @@ +--- +date: '2026-01-21' +description: GroupDocs.Search for Java を使用してシャードを最適化する方法、検索ネットワークの構成方法、テキスト検索の実行方法、ポート競合の処理方法を学びましょう。 +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: Java 用 GroupDocs.Search のシャード最適化方法：包括的ガイド +type: docs +url: /ja/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# GroupDocs.Search for Java におけるシャード最適化方法：包括的ガイド + +効率的な文書検索は、大規模データベースを管理する開発者や企業、内部文書取得プロセスを効率化したい組織にとって不可欠です。**シャードの最適化方法**が気になる方のために、本ガイドではパフォーマンス向上、検索ネットワークの構成、ポート競合などの一般的な課題への対処手順を詳しく解説します。**GroupDocs.Search Java** は検索ネットワークのシームレスな構成と最適化を提供し、パフォーマンスとユーザー体験の両方を向上させます。 + +## Quick Answers +- **シャード最適化とは？** インデックスデータを再編成し、クエリ速度を向上させ、ストレージ負荷を削減します。 +- **検索ネットワークの構成方法は？** ベースディレクトリとポートを定義し、提供された API を使用してノードをデプロイします。 +- **テキスト検索の実行方法は？** `TextSearchInNetwork.searchAll` に検索文字列を渡して使用します。 +- **Java で文書をインデックス化する方法は？** `IndexingDocuments.addDirectories` を使ってマスターノードに文書ディレクトリを追加します。 +- **ポート競合の対処方法は？** `basePort` 変数をマシン上で未使用のポートに変更します。 + +## How to Configure Search Network +インデックス作成や検索に入る前に、堅牢なネットワーク基盤が必要です。このセクションでは、ネットワークのセットアップ手順、ポートの選択、一般的なポート競合問題の回避方法を説明します。 + +## How to Index Documents Java +ネットワークが稼働したら、次はコンテンツを投入します。複数の文書フォルダーを追加して、エンジンが検索可能なインデックスを構築できるようにする方法を示します。 + +## How to Perform Text Search +インデックス化が完了したら、情報を迅速に取得したいでしょう。このパートでは、すべてのノードに対してテキストクエリを実行する最もシンプルな方法を実演します。 + +## How to Handle Port Conflicts +デフォルトポート（`49132`）が既に使用中の場合は、`basePort` の値を空いているポートに変更し、設定を再起動するだけです。これにより起動エラーを防ぎ、ネットワークの安定性が保たれます。 + +## Prerequisites +開始する前に、以下の前提条件が整っていることを確認してください。 + +### Required Libraries, Versions, and Dependencies +このソリューションを実装するには、Maven で `pom.xml` に次の設定を追加して 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/) からダウンロードしてください。 + +### Environment Setup Requirements +- Java (JDK 8 以降) がサポートされている開発環境であることを確認してください。 +- ポート使用を許可するネットワーク構成が利用可能であること。 + +### Knowledge Prerequisites +Java の基本的なプログラミング知識（オブジェクト指向の概念や例外処理など）が本チュートリアルを進める上で役立ちます。 + +## Setting Up GroupDocs.Search for Java +プロジェクトで GroupDocs.Search を使用し始める手順は以下の通りです。 + +1. **依存関係の追加**：上記のように Maven 依存関係をプロジェクトに追加するか、リリースページから直接ダウンロードします。 + +2. **ライセンス取得**： + - 無料トライアルの場合、機能制限はありますがライブラリを制限なく使用できます。 + - 評価期間中にフル機能を利用したい場合は、[GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/) から一時ライセンスを取得してください。 + - 本番環境での利用を決定したら、正式ライセンスを購入します。 + +3. **基本的な初期化と設定**：`Configuration` クラスを使用して設定を初期化し、文書のベースパスとポート番号を指定します。 + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Implementation Guide +それでは、GroupDocs.Search Java の主要機能実装を見ていきましょう。 + +### Feature: Configuring Search Network +**概要**：検索ネットワークを設定するには、文書ディレクトリを定義し、ノード間通信に使用するポートを指定します。 + +#### Step 1: Define Document Directories and Port +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Step 2: Configure Search Network +定義したパスを使用して設定オブジェクトを作成します。 + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Feature: Deploying Search Network Nodes +**概要**：ネットワーク全体で文書検索を効率的に処理できるよう、ノードをデプロイします。 + +#### Step 1: Deploy Nodes Using Configuration +検索ネットワークノードをデプロイし、集中管理用のマスターノードを特定します。 + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Feature: Subscribing to Network Node Events +**概要**：重要な変更やアクションを通知するイベントにサブスクライブして、検索ネットワークを監視します。 + +#### Step 1: Subscribe to Master Node Events +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Feature: Indexing Documents in Network Nodes +**概要**：検索効率を高めるために、文書が格納されたディレクトリをインデックス処理に追加します。 + +#### Step 1: Add Document Directories to Indexing Process +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Feature: Text Search in Network Nodes +**概要**：検索ネットワーク内のすべてのインデックス化された文書に対してテキスト検索を実行します。 + +#### Step 1: Perform a Text Search +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Feature: Optimizing Shards +**概要**：検索ネットワークノードのインデクサ内でシャードを最適化し、パフォーマンスを向上させます。 + +#### Step 1: Optimize Indexer Shards +シャードを最適化して検索効率を高めます（ここが **シャードの最適化方法** の核心です）。 + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Practical Applications +GroupDocs.Search for Java はさまざまな実務シナリオで活用できます： +1. **エンタープライズ文書管理**：大規模企業データベース全体で文書取得を容易にします。 +2. **E コマースプラットフォーム**：最適化されたインデックスとクエリ機能で商品検索を強化します。 +3. **法律事務所**：膨大なアーカイブからケースファイルや文書を効率的に管理・取得します。 +4. **図書館システム**：デジタルライブラリと統合し、カタログ検索を迅速化します。 +5. **コンテンツ管理システム (CMS)**：高度な検索機能でコンテンツの発見性を向上させます。 + +## Performance Considerations +GroupDocs.Search の実装で最適なパフォーマンスを維持するために： +- 定期的にシャードを最適化し、クエリ応答時間を短縮します。 +- 大規模データセットを扱う環境ではメモリ使用量を監視・管理します。 +- Java のガベージコレクションやリソース管理のベストプラクティスに従い、システム効率を保ちます。 + +## Conclusion +本包括的ガイドに従って、GroupDocs.Search for Java を用いた検索ネットワークの構築とシャード最適化の方法を習得しました。これらのスキルにより、さまざまなアプリケーションで効率的な文書検索を実現し、プロジェクトのパフォーマンスとユーザー体験を向上させることができます。さらに GroupDocs.Search の機能を他システムと統合したり、公式ドキュメントに掲載されている追加機能を探索したりしてみてください。 + +## FAQ Section +1. **シャード最適化とは何ですか？** + - シャード最適化は、各シャード内のデータをより効率的に整理し、検索ネットワークのパフォーマンスを向上させます。 +2. **検索ネットワーク構成時にポート競合が発生したらどうすればよいですか？** + - `basePort` 変数をシステム上の未使用ポートに変更し、設定プロセスを再実行します。 +3. **GroupDocs.Search は既存の Java アプリケーションに統合できますか？** + - はい、ライブラリ依存関係をプロジェクトに追加するだけでシームレスに統合できます。 +4. **セットアップ時に遭遇しやすい問題は何ですか？** + - 主な問題はポート設定ミスや依存関係の欠如です。前提条件を正確に満たしていることを確認してください。 + +## Frequently Asked Questions + +**Q: シャード最適化はクエリ速度にどのように影響しますか？** +A: シャードを最適化するとインデックスが圧縮され、ディスク I/O が削減が高速化します。 + +**Q: 稼働中のノードで `optimizeShards` を実行しても安全ですか規模インデックスの場合はトラフィックが少ない時間帯にスケジュールするのがベストです。 + +**Q: `OptimizeOptions` をカスタマイズできますか？** +A: もちろんです。`maxSegmentSize` や `mergeFactor` などのパラメータを設定して最適化プロセスを微調整**除された文書の領域も回収しますか？** +A: はいを除去して削除済み文書が占有していた領域を解放します。 + +--- + +**最終更新日:** 2026-01-21 +**テスト環境:** GroupDocs.Search 25.4 for Java +**作者:** GroupDocs + +--- \ No newline at end of file diff --git a/content/korean/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md b/content/korean/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md new file mode 100644 index 00000000..669f4ea6 --- /dev/null +++ b/content/korean/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md @@ -0,0 +1,224 @@ +--- +date: '2026-01-21' +description: GroupDocs Maven 종속성을 추가하고, Java 검색 네트워크를 구성 및 동기화하며, GroupDocs.Search를 + 사용하여 인덱싱할 디렉터리를 추가하는 방법을 배웁니다. +keywords: +- Java Search Network Configuration +- GroupDocs.Search for Java +- Document Indexing and Retrieval +title: GroupDocs Maven 종속성 – Java 검색 네트워크 동기화 +type: docs +url: /ko/java/search-network/java-groupdocs-search-configuration-sync-guide/ +weight: 1 +--- + +# GroupDocs Maven Dependency: Java 검색 네트워크 구성 및 동기화 + +이 포괄적인 가이드에서는 프로젝트에 **GroupDocs Maven dependency를 추가하는 방법**과 GroupDocs.Search를 사용하여 강력한 Java 검색 네트워크를 구성하는 방법을 알아봅니다. 법률 문서, 재무 보고서 또는 학술 논문을 다루는 경우에도 아래 단계는 인덱싱, 검색 및 샤드를 효율적으로 동기화하는 데 도움이 됩니다. + +## 소개 + +방대한 문서 컬렉션을 관리하고 검색하는 것은 많은 조직에게 매일의 과제입니다. **GroupDocs Maven dependency**를 통합하면 여러 노드에 걸쳐 확장 가능한 강력한 인덱싱 엔진을 사용할 수 있습니다. 이 튜토리얼에서는 의존성을 설정하고, 네트워크 노드를 배포하며, 인덱싱할 디렉터리를 추가하고, 최적의 성능을 위해 샤드를 동기화하는 과정을 단계별로 안내합니다. + +### 빠른 답변 +- **GroupDocs Maven dependency란 무엇입니까?** GroupDocs.Search 라이브러리를 Java 프로젝트에 가져오는 Maven 아티팩트입니다. +- **왜 검색 네트워크를 사용합니까?** 인덱싱 및 쿼리 부하를 여러 노드에 분산시켜 속도와 안정성을 향상시킵니다. +- **인덱싱할 디렉터리를 어떻게 추가합니까?** 마스터 노드에서 `IndexingDocuments.addDirectories`를 사용합니다. +- **샤드를 어떻게 동기화합니까?** 각 노드의 `Indexer`에서 `SynchronizeOptions`를 호출합니다. +- **라이선스가 필요합니까?** 예, 프로덕션 사용을 위해서는 체험판 또는 상용 라이선스가 필요합니다. + +## GroupDocs Maven Dependency란? + +GroupDocs Maven dependency (`com.groupdocs:groupdocs-search`)는 검색 가능한 인덱스를 구축하고, 네트워크 노드를 관리하며, 빠른 쿼리를 수행하는 데 필요한 모든 클래스를 패키징합니다. `pom.xml`에 추가하면 Maven이 올바른 바이너리와 전이적 의존성을 자동으로 가져옵니다. + +## GroupDocs Maven Dependency 추가 방법 + +### Maven 구성 + +`pom.xml`에 저장소와 의존성을 추가합니다: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +> **팁:** 공식 릴리스 페이지를 확인하여 버전 번호를 최신 상태로 유지하세요. + +공식 사이트에서 JAR를 직접 다운로드할 수도 있습니다: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +## 사전 요구 사항 + +- **JDK** (11 이상) 설치 +- IntelliJ IDEA 또는 Eclipse와 같은 IDE +- 기본 Java 지식, Maven 사용 경험, 네트워크 노드 개념에 대한 이해 +- 유효한 GroupDocs.Search 라이선스(무료 체험 또는 상용) + +## 기본 초기화 및 설정 + +인덱스 디렉터리를 생성합니다: + +```java +import com.groupdocs.search.SearchIndex; +import com.groupdocs.search.options.IndexingOptions; + +// Create an index in the specified directory +SearchIndex index = new SearchIndex("YOUR_INDEX_DIRECTORY"); +``` + +이 간단한 단계는 이후 네트워크 구성을 위한 환경을 준비합니다. + +## 구현 가이드 + +### 기능 1: 검색 네트워크 구성 + +#### 개요 + +검색 네트워크를 구성하면 노드가 통신에 사용할 파일 경로와 포트를 설정하게 됩니다. + +##### 경로 및 포트 설정 +```java +import com.groupdocs.search.options.*; +import com.groupdocs.search.scaling.configuring.ConfiguringSearchNetwork; + +// Set custom paths for input/output directories +String basePath = "YOUR_DOCUMENT_DIRECTORY/AdvancedUsage/Scaling/SynchronizingShards/"; +int basePort = 49144; // Adjust if there's a port conflict + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` +`configuration` 객체가 이제 검색 네트워크에 필요한 모든 설정을 보유합니다. + +### 기능 2: 검색 네트워크 노드 배포 + +#### 개요 + +노드를 배포하여 네트워크 전반에 작업 부하를 분산합니다. 마스터 노드는 작업 및 이벤트를 관리합니다. + +##### 배포 코드 +```java +import com.groupdocs.search.scaling.*; +import com.groupdocs.search.options.Configuration; + +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +// Retrieve the master node for further operations +SearchNetworkNode masterNode = nodes[0]; +``` + +### 기능 3: 검색 네트워크 노드 이벤트 구독 + +#### 개요 + +이벤트를 수신하면 네트워크 내 변경 사항이나 업데이트를 동적으로 처리할 수 있습니다. + +##### 구독 구현 +```java +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.scaling.SearchNetworkNodeEvents; + +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### 기능 4: 인덱스에 디렉터리 추가 + +#### 개요 + +디렉터리를 추가하는 것은 문서를 검색 가능하게 만드는 핵심 단계입니다. + +##### 문서 추가 +```java +import com.groupdocs.search.indexing.IndexingDocuments; +import com.groupdocs.search.scaling.SearchNetworkNode; + +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +``` + +### 기능 5: 검색 네트워크 노드에서 샤드 동기화 + +#### 개요 + +동기화는 모든 샤드 간 데이터 일관성을 보장합니다. + +##### 동기화 코드 +```java +import com.groupdocs.search.indexing.Indexer; +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.options.SynchronizeOptions; + +SearchNetworkNode node = null; // Assume 'node' is initialized as a SearchNetworkNode + +def synchronizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + SynchronizeOptions options = new SynchronizeOptions(); + indexer.synchronize(options); +} +``` + +### 기능 6: 검색 네트워크 노드 종료 + +#### 개요 + +노드를 올바르게 종료하면 리소스를 해제하고 메모리 누수를 방지할 수 있습니다. + +##### 노드 종료 +```java +import com.groupdocs.search.scaling.SearchNetworkNode; + +for (SearchNetworkNode node : nodes) { + node.close(); +} +``` + +## 실용적인 적용 사례 + +1. **법률 문 사항 + +적화메모리 관리** – JVM 힙 사용량을 모니터링하고 대형 인덱스의 경우 GC 튜닝을 고려 +- **스케일링 전략** – 데이터 양과 쿼리 부하에 비례하여 노드를 추가 + +## 일반적인 문제 및 해결책 + +| 문제 | 원인 | 해결책 | +|------|------|--------| +| 노드 연결 실패 | 포트 충돌 | `basePort`를 사용되지 않는 값으로 변경 | +| 인덱스 업데이트 안 됨 | 이벤트 구독 누락 | `SearchNetworkNodeEvents.subscribe(masterNode)`가 호출되었는지 확인 | +| 높은 지연 시간 | 샤드 부족 | 노드 수를 늘리고 문서 분배를 균형 있게 조정 | + +## 자주 묻는 질문 + +**Q: GroupDocs.Search를 사용하면 얻을 수 있는 주요 이점은 무엇입니까?** +A: 대용량 문서 집합에 대해 최소한의 구성으로 빠르고 확장 가능한 검색 기능을 제공합니다. + +**Q: 검색 네트워크에서 노드 구성을 사용자 정의할 수 있습니까?** +A: 예, `Configuration` 객체를 통해 사용자 정의 경로, 포트 및 기타 옵션을 설정할 수 있습니다. + +**Q: 네트워크가 실행 중인 후에 디렉터리를 인덱스에 어떻게 추가합니까?** +A: 새 폴더를 인덱싱해야 할 때마다 `IndexingDocuments.addDirectories(masterNode, "path")`를 호출합니다. + +**Q: 새로운 노드가 네트워크에 합류할 때 샤드를 어떻게 동기화합니까?** +A: 위에서 보여준 `synchronizeShards` 메서드를 새로 추가된 노드에서 사용합니다. + +**Q: 개발용으로도 라이선스가 필요합니까?** +A: 테스트용으로는 무료 체험 라이선스로 충분하지만, 프로덕션에서는 상용 라이선스가 필요합니다. + +## 결론 + +이 가이드를 따라 **GroupDocs Maven dependency를 추가하는 방법**, 다중 노드 검색 네트워크 구성, 디렉터리 인덱싱 및 샤드 동기화 방법을 이제 알게 되었습니다. 이러한 단계는 조직의 요구에 맞춰 확장 가능한 고성능 문서 검색 솔루션의 기반을 마련합니다. + +--- + +**마지막 업데이트:** 2026-01-21 +**테스트 환경:** GroupDocs.Search 25.4 +**작성자:** GroupDocs \ No newline at end of file diff --git a/content/korean/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/korean/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..1105a5de --- /dev/null +++ b/content/korean/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,200 @@ +--- +date: '2026-01-21' +description: GroupDocs.Search for Java를 사용하여 샤드를 최적화하는 방법과 검색 네트워크를 구성하고, 텍스트 검색을 + 수행하며, 포트 충돌을 처리하는 방법을 배웁니다. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Java용 GroupDocs.Search에서 샤드 최적화 방법: 종합 가이드' +type: docs +url: /ko/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +상,돌과 같은 일반적인 문제 처리 단계를 안내합니다. **GroupDocs.Search Java**는 검색 네트워크의 원활한 구성 및 최적화를 제공하여 성능과 사용자 경험을 모두 향상시킵니다. + +## 빠른 답변 +- **샤드 최적화란?** 인덱스 데이터를 재구?** 기본 디렉터리와 포트를 정의한 다음 제공된 API- **텍스트 검색을 어떻게 수행하나요?** `TextSearchInNetwork.searchAll`을 사용하여 쿼리 문자열을 전달합니다. +- **Java에서 문서를 어떻게 인덱싱하나요?** `IndexingDocuments.addDirectories`를 사용해 마스터 노드에 문서 디렉터리를 추가합니다. + 방법 인스를 구축할 수 있도록 여러 문서 폴더를 추가하는 방법을 보여드립니다. + +## 텍스트 검색 수행 방법 +인덱싱이 완료되면 정보를 빠르게 검색하고 싶을 것입니다. 이 부분에서는 모든 노드에서 텍스트 쿼리를 실행하는 가장 간단한 방법을 보여줍니다. + +## 포트 충돌 처리 방법 +기본 포트(`49132`)가 이미 사용 중인 경우, `basePort` 값을 사용 가능한 포트로 변경하고 구성을 다시 시작하면 됩니다. 이렇게 하면 시작 오류를 방지하고 네트워크를 안정적으로 유지할 수 있습니다. + +## 사전 요구 사항 +시작하기 전에 다음 사전 요구 사항이 준비되어 있는지 확인하십시오: + +### 필수 라이브러리, 버전 및 종속성 +이 솔루션을 구현하려면 Maven을 사용해 `pom.xml` 파일에 다음 구성을 추가하여 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 (JDK 8 이상)를 지원하는지 확인하십시오. +- 포트 사용을 허용하는 네트워크 구성이 가능한지 확인하십시오. + +### 지식 사전 요구 사항 +객체 지향 원칙 및 예외 처리 등을 포함한 Java 프로그래밍에 대한 기본적인 이해가 이 튜토리얼에 도움이 됩니다. + +## GroupDocs.Search for Java 설정 +프로젝트에서 GroupDocs.Search를 사용하려면 다음 단계를 따르세요: + +1. **의존성 추가**: 위와 같이 프로젝트에 필요한 Maven 의존성을 추가하거나 릴리스 페이지에서 직접 다운로드하십시오. +2. **License Acquisition**: + - 무료 체험의 경우, 기능에 제한 없이 라이브러리를 사용할 수 있지만 일부 사용 제한이 있습니다. + - 평가 기간 동안 전체 기능을 사용하려면 [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/)에서 임시 라이선스를 획득하십시오. + - 프로덕션 환경에 GroupDocs.Search를 통합하기로 결정하면 정식 라이선스를 구매하십시오. +3. **기본 초기화 및 설정**: `Configuration` 클래스를 사용해 구성을 초기화하고, 문서의 기본 경로와 포트 번호를 지정합니다: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## 구현 가이드 +이제 GroupDocs.Search Java를 사용한 주요 기능 구현을 살펴보겠습니다. + +### 기능: 검색 네트워크 구성 +**개요**: 검색 네트워크를 설정하려면 문서 디렉터리를 정의하고 노드 간 통신을 위한 특정 포트를 구성해야 합니다. + +#### 단계 1: 문서 디렉터리 및 포트 정의 +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### 단계 2: 검색 네트워크 구성 +정의된 경로를 사용해 구성 객체를 생성합니다: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### 기능: 검색 네트워크 노드 배포 +**개요**: 네트워크 전반에 걸쳐 문서 검색을 효율적으로 처리하도록 노드를 배포합니다. + +#### 단계 1: 구성을 사용해 노드 배포 +검색 네트워크 노드를 배포하고 중앙 관리를 위한 마스터 노드를 식별합니다: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### 기능: 네트워크 노드 이벤트 구독 +**개요**: 중요한 변경 사항이나 동작을 알려주는 이벤트에 구독하여 검색 네트워크를 모니터링합니다. + +#### 단계 1: 마스터 노드 이벤트 구독 +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### 기능: 네트워크 노드에서 문서 인덱싱 +**개요**: 효율적인 검색을 위해 문서를 포함한 디렉터리를 인덱싱 프로세스에 추가합니다. + +#### 단계 1: 인덱싱 프로세스에 문서 디렉터리 추가 +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### 기능: 네트워크 노드에서 텍스트 검색 +**개요**: 검색 네트워크 내 모든 인덱스된 문서에 대해 텍스트 검색을 실행합니다. + +#### 단계 1: 텍스트 검색 수행 +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### 기능: 샤드 최적화 +**개요**: 검색 네트워크 노드의 인덱서 내 샤드를 최적화하여 성능을 향상시킵니다. + +#### 단계 1: 인덱서 샤드 최적화 +샤드를 최적화하여 검색 효율성을 향상시킵니다(여기서 **샤드 최적화 방법**이 실제로 중요합니다): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## 실용적인 적용 사례 +GroupDocs.Search for Java를 다양한 실제 시나리오에 적용할 수 있습니다: +1. **Enterprise Document Management**: 대규모 기업 데이터베이스 전반에 걸쳐 문서 검색을 용이하게 합니다. +2. **E‑commerce Platforms**: 최적화된 인덱싱 및 쿼리 기능을 사용해 제품 검색 기능을 강화합니다. +3. **Legal Firms**: 방대한 아카이브에서 사건 파일 및 문서를 효율적으로 관리하고 검색합니다. +4. **Library Systems**: 디지털 도서관 시스템과 통합하여 빠른 검색을 위한 카탈로그 작업을 간소화합니다. +5. **Content Management Systems (CMS)**: 고급 검색 기능을 통해 콘텐츠 발견 가능성을 향상시킵니다. + +## 성능 고려 사항 +GroupDocs.Search 구현의 최적 성능을 보장하려면: +- 쿼리 응답 시간을 줄이기 위해 샤드를 정기적으로 최적화합니다. +- 특히 대용량 데이터셋을 처리하는 환경에서는 메모리 사용량을 모니터링하고 관리합니다. +- 시스템 효율성을 유지하기 위해 가비지 컬렉션 및 리소스 관리에 대한 Java 모범 사례를 따릅니다. + +## 결론 +이 종합 가이드를 따라 하면 GroupDocs.Search for Java를 사용해 검색 네트워크를 설정하고 최적화하는 방법을 배웠습니다. 이제 이러한 기술을 통해 다양한 애플리케이션에서 효율적인 문서 검색을 수행하여 프로젝트 성능과 사용자 경험을 향상시킬 수 있습니다. GroupDocs.Search의 기능을 더 탐색하려면 다른 시스템과 통합하거나 문서에 제공되는 추가 기능을 살펴보세요. + +## FAQ 섹션 +1. **샤드 최적화란?** + - 샤드 최적화는 각 샤드 내 데이터를 보다 효율적으로 구성하여 검색 네트워크 성능을 향상시킵니다. +2. **검색 네트워크를 구성할 때 포트 충돌을 어떻게 처리하나요?** + - 시스템에서 사용되지 않는 포트로 `basePort` 변수를 변경하고 구성 프로세스를 다시 시작합니다. +3. **GroupDocs.Search를 기존 Java 애플리케이션에 통합할 수 있나요?** + - 예, 프로젝트에 라이브러리 의존성을 포함하면 원활하게 통합할 수 있습니다. +4. **설정 중 흔히 발생하는 문제는 무엇인가요?** + - 일반적인 문제로는 잘못된 포트 설정 및 누락된 종속성이 있으며, 사전 요구 사항을 정확히 따르세요. + +## 자주 묻는 질문 + +**Q: 샤드 최적화가 쿼리 속도에 어떤 영향을 미치나요?** +A: 샤드를 최적화하면 인덱스가 압축되고 디스크 I/O가 감소하여 일반적으로 더 빠른 쿼리 응답을 제공합니다. + +**Q: 라이브 노드에서 `optimizeShards`를 실행해도 안전한가요?** +A: 예, 이 작업은 다운타임 없이 실행되도록 설계되었지만, 대규모 인덱스의 경우 트래픽이 적은 시간에 예약하는 것이 좋습니다. + +**Q: `OptimizeOptions`를 사용자 정의할 수 있나요?** +A: 물론입니다. `maxSegmentSize` 또는 `mergeFactor`와 같은 매개변수를 설정하여 최적화 프로세스를 세밀하게 조정할 수 있습니다. + +**Q: 최적화 중 `IOException`이 발생하면 어떻게 해야 하나요?** +A: 파일 시스템 권한을 확인하고 충분한 디스크 공간을 확보한 뒤, 다른 프로세스가 인덱스 파일을 잠그고 있지 않은지 확인하십시오. + +**Q: 샤드 최적화가 삭제된 문서 공간도 회수하나요?** +A: 예, 옵티마이저가 세그먼트를 병합하고 톰스톤을 제거하여 삭제된 문서가 차지하던 공간을 해제합니다. + +--- + +**마지막 업데이트:** 2026-01-21 +**테스트 환경:** GroupDocs.Search 25.4 for Java +**작성자:** GroupDocs \ No newline at end of file diff --git a/content/polish/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/polish/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md new file mode 100644 index 00000000..1d9cdc40 --- /dev/null +++ b/content/polish/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -0,0 +1,217 @@ +--- +date: '2026-01-21' +description: Dowiedz się, jak poprawić wydajność zapytań i dodać dokumenty do indeksu, + jednocześnie prawidłowo escapując specjalne znaki w zapytaniu przy użyciu GroupDocs.Search + Java. +keywords: +- GroupDocs.Search Java +- document index optimization +- search query performance +title: 'Popraw wydajność zapytań w GroupDocs.Search Java: zoptymalizuj indeks i wyszukiwanie' +type: docs +url: /pl/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/ +weight: 1 +--- + +# Popraw wydajność zapytań z GroupDocs.Search Java: optymalizacja indeks od **poprawy wydajności zapytań**. W tym samouczku dowiesz się, jak utworzyć i skonfigurować wysokowydajny indeks, **dodać dokumenty do indeksu** oraz prawidłowo **uciec specjalne znaki w zapytaniu**, aby wyszukiwania były szybkie i zwracały dokładne wyniki. Niezależnie od tego, czy tworzysz korporacyjną bazę wiedzy, czy przeszukiwalny katalog e‑commerce, opanowanie tych kroków zapewni responsywność aplikacji przy dużym obciążeniu. + +## Szybkie odpowiedzi +- **Jaki jest główny cel?** Poprawa wydajności zapytań poprzez dopasowanie indeksu i obsługę zapytań. +- **Jakiej biblioteki używamy?** GroupDocs.Search dla Java. +- **Czy potrzebna jest licencja?** Wystarczająca jest darmowa wersja próbna lub tymczasowa licencja do celów deweloperskich; pełna licencja jest wymagana w środowisku produkcyjnym. +- **Jak dodać dokumenty?** Użyj `index.add("YOUR_DOCUMENT_DIRECTORY")`, aby załadować pliki hurtowo. +- **Jak obsługiwane są specjalne znaki?** Skonfiguruj słownik alfabetu i ucieknij znaki takie jak `()":&|!^~*?` przed wykonaniem wyszukiwania. + +## Co to jest „poprawa wydajności zapytań”? +Poprawa wydajności zapytań oznacza skrócenie czasu, jaki potrzebny jest na przetworzenie żądania wyszukiwania przez indeks, dopasowanie terminów i zwrócenie wyników. Dzięki prawidłowej konfiguracji indeksu oraz przygotowaniu zapytań zgodnych z tą konfiguracją eliminujesz niepotrzebne przetwarzanie i osiągasz szybsze czasy odpowiedzi. + +## Dlaczego warto używać GroupDocs.Search Java do wysokowydajnych wyszukiwań? +- **Skalowalne indeksowanie** – obsługuje miliony dokumentów z aktualizacjami przyrostowymi. +- **Bogate wsparcie językowe** – wbudowane analizatory dla wielu alfabetów i znaków specjalnych. +- **Łatwa integracja** – działa z każdą aplikacją opartą na Javie, od usług Spring Boot po narzędzia desktopowe. + +## Wymagania wstępne + +Zanim przejdziesz dalej, upewnij się, że masz przygotowane następujące elementy: + +### Wymagane biblioteki i zależności +Aby używać GroupDocs.Search w projekcie Maven, dodaj poniższą konfigurację: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Konfiguracja środowiska +- Zainstalowany i skonfigurowany JDK 8 lub nowszy. +- IDE, takie jak IntelliJ IDEA lub Eclipse. + +### Wymagania merytoryczne +- Podstawowa znajomość programowania w Javie. +- Znajomość Maven. +- Rozumienie koncepcji zarządzania dokumentami. + +## Konfiguracja GroupDocs.Search dla Java + +### 1. Instalacja przez Maven lub pobranie ręczne +Dodaj fragment XML powyżej do pliku `pom.xml`. Jeśli wolisz podejście ręczne, pobierz bibliotekę ze strony oficjalnej: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### 2. Uzyskanie licencji +Darmową wersję próbną lub tymczasową licencję możesz pobrać tutaj: + +[GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license) + +### 3. Podstawowa inicjalizacja +Utwórz obiekt `Index`, który wskazuje folder, w którym będą przechowywane pliki indeksu: + +```java +import com.groupdocs.search.*; + +public class SearchInitialization { + public static void main(String[] args) { + Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); + System.out.println("GroupDocs.Search initialized successfully."); + } +} +``` + +## Przewodnik implementacji + +### Tworzenie i konfigurowanie indeksu +Konfiguracja słownika alfabetu pozwala określić, jak traktowane są znaki specjalne, co jest kluczowe dla **poprawy wydajności zapytań**. + +#### Krok 1: Inicjalizacja indeksu +```java +Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); +``` + +#### Krok 2: Konfiguracja typów znaków +```java +index.getDictionaries().getAlphabet() + .setRange(new char[] {'&'}, CharacterType.Letter) + .setRange(new char[] {'-'}, CharacterType.Separator); +``` +Traktowanie `&` jako litery i `-` jako separatora zapewnia, że silnik wyszukiwania analizuje zapytania tak, jak tego oczekujesz. + +### Indeksowanie dokumentów +Teraz **dodaj dokumenty do indeksu**, aby stały się przeszukiwalne. + +#### Krok 3: Dodawanie dokumentów +```java +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` +Metoda skanuje podany folder rekurencyjnie i indeksuje każdy obsługiwany typ pliku. + +### Przygotowanie zapytania wyszukiwania +Aby **uciec specjalne znaki w zapytaniu**, najpierw normalizujemy wejście na podstawie konfiguracji alfabetu, a następnie dodajemy sekwencje ucieczki. + +#### Krok 4: Modyfikacja znaków specjalnych +```java +StringBuilder result = new StringBuilder(); +String word = "rock&roll-music"; + +for (int i = 0; i < word.length(); i++) { + char character = word.charAt(i); + CharacterType characterType = index.getDictionaries().getAlphabet().getCharacterType(character); + + if (characterType == CharacterType.Separator) { + result.append(' '); + } else { + result.append(character); + } +} +``` + +#### Krok 5: Ucieczka znaków specjalnych +```java +String specialCharacters = "()\":&|!^~*?"; +for (int i = result.length() - 1; i >= 0; i--) { + char c = result.charAt(i); + if (specialCharacters.indexOf(c) != -1) { + result.insert(i, '\\'); + } +} +String query = result.toString(); +if (query.contains(" ")) { + query = "\"" + query + "\""; +} +``` +Ucieczka zapobiega błędnemu interpretowaniu symboli jako operatorów przez parser. + +### Wykonanie wyszukiwania +Na koniec uruchom zapytanie przeciwko przygotowanemu indeksowi. + +#### Krok 6: Wykonanie wyszukiwania +```java +import com.groupdocs.search.results.*; + +SearchResult searchResult = index.search(query); +``` +Metoda `search` zwraca obiekt `SearchResult` zawierający dopasowane dokumenty, fragmenty oraz oceny trafności. + +## Praktyczne zastosowania + +### Studium przypadku 1: Systemy zarządzania dokumentami +Kancelarie prawne mogą szybko odnajdywać akta spraw, indeksując pliki PDF, dokumenty Word oraz e‑maile. Dzięki **poprawie wydajności zapytań** prawnicy spędzają mniej czasu na oczekiwaniu na wyniki, a więcej na analizie treści. + +### Studium przypadku 2: Platformy e‑commerce +Sklepy internetowe indeksują opisy produktów, specyfikacje i recenzje. Prawidłowo uciekane zapytania pozwalają klientom wyszukiwać frazy takie jak `4‑K TV` bez błędów, a szybka realizacja zapytań zapewnia płynne doświadczenie zakupowe. + +## Wskazówki dotyczące wydajności i porady + +- **Odśwież indeks** po masowych importach lub dużych aktualizacjach, aby utrzymać niskie opóźnienia wyszukiwania. +- **Przydziel wystarczającą pamięć heap** (`-Xmx2g` lub więcej) dla dużych zbiorów danych. +- **Wykorzystuj istniejącą instancję `Index`** w wielu wyszukiwaniach zamiast tworzyć ją za każdym razem. +- **Profiluj wykonanie zapytań** przy użyciu wbudowanych narzędzi Javy, aby zidentyfikować wąskie gardła. + +## Typowe pułapki i rozwiązania + +| Problem | Dlaczego się pojawia | Rozwiązanie | +|---------|----------------------|-------------| +| Zapytania nie zwracają wyników po dodaniu nowych plików | Indeks nie został zaktualizowany | Wywołaj `index.add(newPath)` lub odbuduj indeks. | +| Błędy związane z nieoczekiwanymi znakami | Znaki specjalne nie zostały ucieknięte | Upewnij się, że logika ucieczki z Kroku 5 jest wykonywana przed wyszukiwaniem. | +| Wysokie zużycie pamięci | Duże zestawy wyników ładowane jednocześnie | Iteruj po `searchResult.getDocuments()` leniwie lub ogranicz wyniki, np. `index.search(query, 100)`. | + +## Najczęściej zadawane pytania + +**P: Jak radzić sobie z bardzo dużymi zestawami danych w GroupDocs.Search?** +O: Korzystaj z przyrostowego indeksowania (`index.add`) i planuj okresowe optymalizacje indeksu. Umieść indeks na dyskach SSD, aby przyspieszyć operacje I/O. + +**P: Czy GroupDocs.Search można zintegrować ze Spring Boot?** +O: Tak. Zdefiniuj bean `Index` w klasie `@Configuration` i wstrzykuj go tam, gdzie potrzebne są funkcje wyszukiwania. + +**P: Które znaki muszą być ucieknięte w zapytaniu?** +O: Znaki `()":&|!^~*?` wymagają poprzedzającego backslasha (`\`), aby były traktowane jako literały. + +**P: Jak zaktualizować istniejący indeks o nowo przesłane dokumenty?** +O: Wywołaj `index.add("NEW_DOCUMENT_DIRECTORY")`; biblioteka scali nowe wpisy bez konieczności pełnej odbudowy indeksu. + +**P: Czy GroupDocs.Search nadaje się do scenariuszy wyszukiwania w czasie rzeczywistym?** +O: Zdecydowanie. Biblioteka obsługuje szybkie przyrostowe aktualizacje i zapytania o niskiej latencji, co czyni ją idealną dla pól wyszukiwania na żywo. + +## Zasoby +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/) + +--- + +**Ostatnia aktualizacja:** 2026-01-21 +**Testowane z:** GroupDocs.Search Java 25.4 +**Autor:** GroupDocs + +--- \ No newline at end of file diff --git a/content/polish/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md b/content/polish/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md new file mode 100644 index 00000000..59b77532 --- /dev/null +++ b/content/polish/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md @@ -0,0 +1,223 @@ +--- +date: '2026-01-21' +description: Dowiedz się, jak dodać zależność GroupDocs Maven, skonfigurować i zsynchronizować + sieć wyszukiwania w Javie oraz dodać katalogi do indeksowania przy użyciu GroupDocs.Search. +keywords: +- Java Search Network Configuration +- GroupDocs.Search for Java +- Document Indexing and Retrieval +title: Zależność Maven GroupDocs – Synchronizacja sieciowa wyszukiwania w Javie +type: docs +url: /pl/java/search-network/java-groupdocs-search-configuration-sync-guide/ +weight: 1 +--- + + synchronizacja sieci wyszukiwania Java + +W tym obszernym przewodniku dowiesz się **jak dodać zależność GroupDocs Maven** do swojego projektu oraz jak skonfigurować solidną sieć wyszukiwania Java przy użyciu GroupDocs, czy pracujesz z dokumentami prawnymi, raportami finansowymi czy pracami akademickimi, poniższe kroki pomogą Ci indeksować, wyszukiwać i utrzymywać shardy w synchronizacji w sposób efektywny. + +## Wprowadzenie + +Zarządzanie i przeszukiwanie ogromnych zbiorów dokumentów to codzienne wyz do indeks celu uz?** Artefakt Maven, który wprowadza bibliotekę GroupDocs.Search do Twojego projektu Java. +- **Dlaczego używać sieci wyszukiwania?** Rozdziela obciążenie indeksowania i zapytań na wiele węzłów, zwiększając szybkość i niezawodność. +- **Jak dodać katalogi do indeksu?** Użyj `IndexingDocuments.addDirectories` na węźle głównym. +- **Jak synchronizować shardy?** Wywołaj `SynchronizeOptions` na `Indexer` każdego węzła. +- **Czy potrzebna jest licenc## Co to jest GroupDocs Maven Dependencycom.groupdocs:groupdocs-search`) zawiera wszystkie klasy potrzebne do tworzenia indeksów przeszukiwalnych, zarządzania węzłami sieci i wykonywania szybkich zapytań. Dodanie jej do pliku `pom.xml` zapewnia, że Maven pobierze odpowiednie pliki binarne oraz zależności tranzytywne. + +## Jak dodać zależność GroupDocs Maven + +### Konfiguracja Maven + +Dodaj repozytorium i zależność do pliku `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +> **Pro tip:** Utrzymuj numer wersji aktualny, sprawdzając oficjalną stronę wydań. + +Możesz również pobrać plik JAR bezpośrednio z oficjalnej strony: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +## Wymagania wstępne + +- **JDK** (11 lub nowszy) zainstalowany. +- Eclipse. +- Podstawowa znajomość Javy, Maven oraz pojęć związanych z węzłami sieci. +- Ważna licencja GroupDocs.Search (bezpłatna wersja próbna lub komercyjna). + +## Podstawowa inicjalizacja i konfiguracja + +Rozpocznij od utworzenia katalogu indeksu: + +```java +import com.groupdocs.search.SearchIndex; +import com.groupdocs.search.options.IndexingOptions; + +// Create an index in the specified directory +SearchIndex index = new SearchIndex("YOUR_INDEX_DIRECTORY"); +``` + +Ten prosty krok przygotowuje środowisko do kolejnej konfiguracji sieci. + +## Przewodnik implementacji + +### Funkcja 1: Konfiguracja sieci wyszukiwania + +#### Przegląd + +Konfiguracja sieci wyszukiwania ustawia ścieżki plików i porty, z których będą korzystać węzły do komunikacji. + +##### Ustawianie ścieżek i portów +```java +import com.groupdocs.search.options.*; +import com.groupdocs.search.scaling.configuring.ConfiguringSearchNetwork; + +// Set custom paths for input/output directories +String basePath = "YOUR_DOCUMENT_DIRECTORY/AdvancedUsage/Scaling/SynchronizingShards/"; +int basePort = 49144; // Adjust if there's a port conflict + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +Obiekt `configuration` zawiera teraz wszystkie niezbędne ustawienia Twojej sieci wyszukiwania. + +### Funkcja 2: Wdrażanie węzłów sieci wyszukiwania + +#### Przegląd + +Wdrażaj węzły, aby rozłożyć obciążenie w całej sieci. Węzeł główny zarządza operacjami i zdarzeniami. + +##### Kod wdrożenia +```java +import com.groupdocs.search.scaling.*; +import com.groupdocs.search.options.Configuration; + +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +// Retrieve the master node for further operations +SearchNetworkNode masterNode = nodes[0]; +``` + +### Funkcja 3: Subskrypcja zdarzeń węzła sieci wyszukiwania + +#### Przegląd + +Nasłuchiwanie zdarzeń umożliwia dynamiczne obsługiwanie zmian lub aktualizacji w Twojej sieci. + +##### Implementacja subskrypcji +```java +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.scaling.SearchNetworkNodeEvents; + +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Funkcja 4: Dodawanie katalogów do indeksu + +#### Przegląd + +Dodawanie katalogów to kluczowy krok, który sprawia, że Twoje dokumenty są przeszukiwalne. + +##### Dodawanie dokumentów +```java +import com.groupdocs.search.indexing.IndexingDocuments; +import com.groupdocs.search.scaling.SearchNetworkNode; + +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +``` + +### Funkcja 5: Synchronizacja shardów w węźle sieci wyszukiwania + +#### Przegląd + +Synchronizacja zapewnia spójność danych we wszystkich shardach. + +##### Kod synchronizacji +```java +import com.groupdocs.search.indexing.Indexer; +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.options.SynchronizeOptions; + +SearchNetworkNode node = null; // Assume 'node' is initialized as a SearchNetworkNode + +def synchronizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + SynchronizeOptions options = new SynchronizeOptions(); + indexer.synchronize(options); +} +``` + +### Funkcja 6: Zamykanie węzłów sieci wyszukiwania + +#### Przegląd + +Poprawne zamykanie węzłów zwalnia zasoby i zapobiega wyciekom pamięci. + +##### Zamykanie węzła +```java +import com.groupdocs.search.scaling.SearchNetworkNode; + +for (SearchNetworkNode node : nodes) { + node.close(); +} +``` + +## Praktyczne zastosowania + +1. **Legal Document Management** – Szybkie odnajdywanie akt spraw i precedensów. +2. **Financial Record Keeping** – Dostęp do wyciągów i ścieżek audytu w kilka sekund. +3. **Academic Research** – Przeszukiwanie tysięcy publikacji w celu znalezienia odpowiednich cytowań. + +## Względy dotyczące wydajności + +- **Optimize Queries** – Twórz zwięzłe zapytania, aby skrócić czas odpowiedzi. +- **Memory Management** – Monitoruj zużycie pamięci heap JVM; rozważ dostrojenie GC dla dużych indeksów. +- **Scaling Strategy** – Dodawaj węzły proporcjonalnie do wolumenu danych i obciążenia zapytań. + +## Typowe problemy i rozwiązania + +| Problem | Przyczyna | Rozwiązanie | +|-------|-------|----------| +| Węzły nie mogą się połączyć | Konflikt portów | Zmień `basePort` na nieużywaną wartość | +| Indeks nie jest aktualizowany | Brak subskrypcji zdarzeń | Upewnij się, że wywołano `SearchNetworkNodeEvents.subscribe(masterNode)` | +| Wysokie opóźnienie | Niewystarczająca liczba shardów | Zwiększ liczbę węzłów i zrównoważ dystrybucję dokumentów | + +## Najczęściej zadawane pytania + +**Q: Jaka jest główna korzyść z używania GroupDocs.Search?** +A: Zapewnia szybkie, skalowalne możliwości wyszukiwania w dużych zestawach dokumentów przy minimalnej konfiguracji. + +**Q: Czy mogę dostosować konfiguracje węzłów w sieci wyszukiwania?** +A: Tak, możesz ustawić własne ścieżki, porty i inne opcje za pomocą obiektu `Configuration`. + +**Q: Jak dodać katalogi do indeksu po uruchomieniu sieci?** +A: Wywołaj `IndexingDocuments.addDirectories(masterNode, "path")` za każdym razem, gdy potrzebujesz zindeksować nowe foldery. + +**Q: Jak synchronizować shardy, gdy nowy węzeł dołącza do sieci?** +A: Użyj metody `synchronizeShards` przedstawionej powyżej na nowo dodanym węźle. + +**Q: Czy potrzebna jest licencja do rozwoju?** +A: Licencja próbna jest wystarczająca do testów; licencja komercyjna jest wymagana w środowisku produkcyjnym. + +## Zakończenie + +Korzystając z tego przewodnika, teraz wiesz, jak **dodać zależność GroupDocs Maven**, skonfigurować wielowęzłową sieć wyszukiwania, indeksować katalogi i utrzymywać shardy w synchronizacji. Te kroki stanowią podstawę wysokowydajnego rozwiązania do wyszukiwania dokumentów, które może rosnąć wraz z potrzebami Twojej organizacji. + +--- + +**Ostatnia aktualizacja:** 2026-01-21 +**Testowane z:** GroupDocs.Search 25.4 +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/polish/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/polish/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..fe392da0 --- /dev/null +++ b/content/polish/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,213 @@ +--- +date: '2026-01-21' +description: Dowiedz się, jak optymalizować shardy przy użyciu GroupDocs.Search dla + Javy oraz jak konfigurować sieć wyszukiwania, wykonywać wyszukiwanie tekstowe i + rozwiązywać konflikty portów. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Jak zoptymalizować shardy w GroupDocs.Search dla Javy: kompleksowy przewodnik' +type: docs +url: /pl/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# Jak optymalizować Shardy w GroupDocs.Search dla Java: Kompletny przewodnik + +Efektywne wyszukiwanie dokumentów jest niezbędne dla programistów i firm zarządzających dużymi bazami danych lub dążących do usprawnienia wewnętrznych procesów odzyskiwania dokumentów. Jeśli zastanawiasz się **jak optymalizować shardy**, ten przewodnik poprowadzi Cię przez kroki poprawiające wydajność, konfigurację sieci wyszukiwania oraz radzenie sobie z typowymi wyzwaniami, takimi jak konflikty portów. **GroupDocs.Search Java** oferuje płynną konfigurację i optymalizację Twojej sieci wyszukiwania, zwiększając zarówno wydajność, jak i doświadczenie użytkownika. + +## Szybkie odpowiedzi +- **Czym jest optymalizacja shardów?** Przeorganizowuje dane indeksu, aby przyspieszyć zapytania i zmniejszyć obciążenie pamięci masowej. +- **Jak skonfigurować sieć wyszukiwania?** Zdefiniuj katalog bazowy i port, a następnie wdroż węzły przy użyciu udostępnionego API. +- **Jak wykonać wyszukiwanie tekstowe?** Użyj `TextSearchInNetwork.searchAll` z ciągiem zapytania. +- **Jak indeksować dokumenty w Javie?** Dodaj katalogi dokumentów do węzła głównego przy użyciu `IndexingDocuments.addDirectories`. +- **Jak radzić sobie z konfliktami portów?** Zmień zmienną `basePort` na nieużywany port w Twoim komputerze. + +## Jak skonfigurować sieć wyszukiwania +Zanim przejdziesz do indeksowania i wyszukiwania, potrzebujesz solidnej podstawy sieciowej. Ta sekcja wyjaśnia kroki konfiguracji sieci, wyboru portu i unikania typowych problemów z konfliktami portów. + +## Jak indeksować dokumenty w Javie +Gdy sieć jest uruchomiona, kolejnym krokiem jest wprowadzenie do niej treści. Pokażemy, jak dodać wiele folderów z dokumentami, aby silnik mógł zbudować indeks przeszukiwalny. + +## Jak wykonać wyszukiwanie tekstowe +Po indeksowaniu będziesz chciał szybko uzyskać informacje. Ta część demonstruje najprostszy sposób uruchomienia zapytania tekstowego na wszystkich węzłach. + +## Jak radzić sobie z konfliktami portów +Jeśli domyślny port (`49132`) jest już używany, po prostu zmień wartość `basePort` na wolny port i uruchom ponownie konfigurację. Zapobiega to błędom przy uruchamianiu i utrzymuje stabilność sieci. + +## Wymagania wstępne +Zanim zaczniemy, upewnij się, że spełniasz następujące wymagania wstępne: + +### Wymagane biblioteki, wersje i zależności +Aby wdrożyć to rozwiązanie, dołącz bibliotekę GroupDocs.Search przy użyciu Maven, dodając następującą konfigurację do pliku `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` +Alternatywnie, pobierz najnowszą wersję z [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Wymagania dotyczące konfiguracji środowiska +- Upewnij się, że Twoje środowisko programistyczne obsługuje Javę (JDK 8 lub nowszy). +- Dostęp do konfiguracji sieciowej umożliwiającej użycie portów. + +### Wymagania wiedzy +Podstawowa znajomość programowania w Javie, w tym zasad programowania obiektowego i obsługi wyjątków, będzie przydatna w tym samouczku. + +## Konfiguracja GroupDocs.Search dla Java +Aby rozpocząć korzystanie z GroupDocs.Search w swoim projekcie, wykonaj następujące kroki: + +1. **Dodaj zależność**: Jak pokazano powyżej, dodaj niezbędną zależność Maven do swojego projektu lub pobierz bezpośrednio ze strony wydań. +2. **Pozyskanie licencji**: + - W ramach darmowej wersji próbnej używaj biblioteki bez ograniczeń funkcji, ale z pewnymi limitami użytkowania. + - Uzyskaj tymczasową licencję, aby mieć pełny dostęp do funkcji podczas oceny, odwiedzając [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/). + - Kup pełną licencję, jeśli zdecydujesz się zintegrować GroupDocs.Search w środowisku produkcyjnym. +3. **Podstawowa inicjalizacja i konfiguracja**: + Zainicjalizuj konfigurację przy użyciu klasy `Configuration`, ustawiając ścieżkę bazową dla dokumentów i określając numer portu: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Przewodnik implementacji +Teraz przyjrzyjmy się implementacji kluczowych funkcji przy użyciu GroupDocs.Search Java. + +### Funkcja: Konfiguracja sieci wyszukiwania +**Przegląd**: Konfiguracja sieci wyszukiwania polega na określeniu katalogu dokumentów i skonfigurowaniu go z określonym portem do komunikacji między węzłami. + +#### Krok 1: Zdefiniuj katalogi dokumentów i port +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Krok 2: Skonfiguruj sieć wyszukiwania +Utwórz obiekt konfiguracji przy użyciu zdefiniowanych ścieżek: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Funkcja: Wdrażanie węzłów sieci wyszukiwania +**Przegląd**: Wdroż węzły, aby efektywnie obsługiwać wyszukiwanie dokumentów w całej sieci. + +#### Krok 1: Wdroż węzły przy użyciu konfiguracji +Wdroż węzły sieci wyszukiwania i zidentyfikuj węzeł główny do scentralizowanego zarządzania: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Funkcja: Subskrypcja zdarzeń węzłów sieci +**Przegląd**: Monitoruj swoją sieć wyszukiwania, subskrybując zdarzenia, które powiadamiają o ważnych zmianach lub akcjach. + +#### Krok 1: Subskrybuj zdarzenia węzła głównego +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Funkcja: Indeksowanie dokumentów w węzłach sieci +**Przegląd**: Dodaj katalogi zawierające dokumenty do procesu indeksowania w celu efektywnego wyszukiwania. + +#### Krok 1: Dodaj katalogi dokumentów do procesu indeksowania +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Funkcja: Wyszukiwanie tekstowe w węzłach sieci +**Przegląd**: Wykonuj wyszukiwania tekstowe we wszystkich zindeksowanych dokumentach w swojej sieci wyszukiwania. + +#### Krok 1: Wykonaj wyszukiwanie tekstowe +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Funkcja: Optymalizacja shardów +**Przegląd**: Zwiększ wydajność poprzez optymalizację shardów w indeksatorze węzła Twojej sieci wyszukiwania. + +#### Krok 1: Optymalizuj shardy indeksatora +Optymalizuj shardy, aby poprawić efektywność wyszukiwania (to jest miejsce, w którym **jak optymalizować shardy** naprawdę ma znaczenie): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Praktyczne zastosowania +GroupDocs.Search dla Java może być zastosowany w różnych rzeczywistych scenariuszach: + +1. **Enterprise Document Management**: Ułatwiaj odzyskiwanie dokumentów w dużych bazach danych korporacyjnych. +2. **E‑commerce Platforms**: Zwiększ możliwości wyszukiwania produktów przy użyciu zoptymalizowanego indeksowania i funkcji zapytań. +3. **Legal Firms**: Efektywnie zarządzaj i odzyskuj akta spraw oraz dokumenty z rozległych archiwów. +4. **Library Systems**: Usprawnij proces katalogowania, integrując się z cyfrowymi systemami bibliotecznymi w celu szybkiego wyszukiwania. +5. **Content Management Systems (CMS)**: Popraw wykrywalność treści dzięki zaawansowanym możliwościom wyszukiwania. + +## Rozważania dotyczące wydajności +Aby zapewnić optymalną wydajność implementacji GroupDocs.Search: + +- Regularnie optymalizuj shardy, aby skrócić czasy odpowiedzi zapytań. +- Monitoruj i zarządzaj użyciem pamięci, szczególnie w środowiskach obsługujących duże zestawy danych. +- Stosuj najlepsze praktyki Javy dotyczące garbage collection i zarządzania zasobami, aby utrzymać efektywność systemu. + +## Zakończenie +Postępując zgodnie z tym kompleksowym przewodnikiem, nauczyłeś się, jak skonfigurować i zoptymalizować sieć wyszukiwania przy użyciu GroupDocs.Search dla Java. Dzięki tym umiejętnościom jesteś gotowy do obsługi efektywnego wyszukiwania dokumentów w różnych aplikacjach, zwiększając wydajność projektu i doświadczenie użytkownika. Aby dalej zgłębiać możliwości GroupDocs.Search, rozważ integrację z innymi systemami lub poznanie dodatkowych funkcji dostępnych w ich dokumentacji. + +## Sekcja FAQ +1. **Czym jest optymalizacja shardów?** + - Optymalizacja shardów poprawia wydajność sieci wyszukiwania poprzez bardziej efektywne organizowanie danych w każdym shardzie. +2. **Jak radzić sobie z konfliktami portów przy konfigurowaniu sieci wyszukiwania?** + - Zmień zmienną basePort na nieużywany port w systemie i uruchom ponownie proces konfiguracji. +3. **Czy GroupDocs.Search może być zintegrowany z istniejącymi aplikacjami Java?** + - Tak, może być płynnie zintegrowany poprzez dołączenie zależności biblioteki w projekcie. +4. **Jakie są typowe problemy napotykane podczas konfiguracji?** + - Typowe problemy to nieprawidłowe konfiguracje portów i brakujące zależności; upewnij się, że dokładnie przestrzegasz wymagań wstępnych. + +## Najczęściej zadawane pytania + +**Q: Jak optymalizacja shardów wpływa na szybkość zapytań?** +A: Optymalizacja shardów kompresuje indeks, zmniejsza operacje I/O na dysku i zazwyczaj skutkuje szybszymi odpowiedziami na zapytania. + +**Q: Czy bezpiecznie jest uruchomić `optimizeShards` na działającym węźle?** +A: Tak, operacja jest zaprojektowana tak, aby działała bez przestojów, ale najlepiej zaplanować ją w okresach niskiego ruchu przy dużych indeksach. + +**Q: Czy mogę dostosować `OptimizeOptions`?** +A: Oczywiście. Możesz ustawić parametry takie jak `maxSegmentSize` lub `mergeFactor`, aby precyzyjnie dostroić proces optymalizacji. + +**Q: Co zrobić, jeśli napotkam `IOException` podczas optymalizacji?** +A: Sprawdź uprawnienia systemu plików, upewnij się, że jest wystarczająco miejsca na dysku oraz że żaden inny proces nie blokuje plików indeksu. + +**Q: Czy optymalizacja shardów również odzyskuje miejsce po usuniętych dokumentach?** +A: Tak, optymalizator łączy segmenty i usuwa „tombstones”, zwalniając miejsce zajmowane przez usunięte dokumenty. + +--- + +**Ostatnia aktualizacja:** 2026-01-21 +**Testowano z:** GroupDocs.Search 25.4 for Java +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/portuguese/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/portuguese/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md new file mode 100644 index 00000000..cae5b8ed --- /dev/null +++ b/content/portuguese/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -0,0 +1,205 @@ +--- +date: '2026-01-21' +description: Aprenda como melhorar o desempenho de consultas e adicionar documentos + ao índice, escapando corretamente caracteres especiais na consulta usando o GroupDocs.Search + Java. +keywords: +- GroupDocs.Search Java +- document index optimization +- search query performance +title: 'Melhore o desempenho de consultas com GroupDocs.Search Java: otimize o índice + e a pesquisa' +type: docs +url: /pt/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/ +weight: 1 +--- + +# Melhorar o Desempenho de Consulta com GroupDocs.Search Java: Otimizar Índice e Busca + +Gerenciar eficientemente uma enorme coleção de documentos começa com **melhorar o desempenho de consulta**. Neste tutorial, você descobrirá como criar e configurar um índice de alto desempenho, **adicionar documentos ao índice**, e escapar corretamenteMelhorar o desempenho de consulta afinando o índice e o teste gratuito ou licença temporária é suficiente para desenvolvimento; uma licença completa é necessária para produção. +- **Como adiciono documentos?** Use `index.add("YOUR_DOCUMENT_DIRECTORY")` para carregar arquivos em lote. +- **Como os caracteres especiais são tratados?** Configure o dicionário alfabético e escape caracteres como `()":&|!^~*?` antes de executar a busca. + +## O que é “melMelhorar o desempenho de consulta significa reduzir o tempo que uma solicitação de busca leva para percorrer o índice, combinar termos e retornar resultados. Ao configurar o índice corretamente e preparar consultas que estejam alinhadas com essa configuração, você elimina processamento desnecessário e obtém tempos de resposta mais rápidos. + +## Por que usar GroupDocs.Search Java para buscas de alto desempenho até o seguinte pronto: + +### Bibliotecas e Dependências Necessárias +Para usar GroupDocs.Search em um projeto Maven, inclua as seguintes configurações: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Configuração do Ambiente +- e configurado. +- IDE como IntelliJ IDEA ou Eclipse. + +### Pré-requisitos de Conhecimento +- Programação básica em Java. +- Familiaridade com Maven. +- Compreensão dos conceitos de gerenciamento de documentos. + +## Configurando GroupDocs.Search para Java + +### 1 Se preferir uma abordagem manual, faça o download da biblioteca no site oficial: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### 2. Obter uma Licença +Você pode obter um teste gratuito ou uma licença temporária aqui: + +[GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license) + +### 3. Inicialização Básica +Crie um objeto `Index` que aponta para uma pasta onde os arquivos de índice serão armazenados: + +```java +import com.groupdocs.search.*; + +public class SearchInitialization { + public static void main(String[] args) { + Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); + System.out.println("GroupDocs.Search initialized successfully."); + } +} +``` + +## Guia de Implementação + +### Criando e Configurando um Índice +Configurar o dicionário alfabético permite decidir como os caracteres especiais são tratados, o que é essencial para **melhorar o desempenho de consulta**. + +#### Etapa 1: Inicializar o Índice +```java +Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); +``` + +#### Etapa 2: Configurar Tipos de Caracteres +```java +index.getDictionaries().getAlphabet() + .setRange(new char[] {'&'}, CharacterType.Letter) + .setRange(new char[] {'-'}, CharacterType.Separator); +``` +Tratar `&` como uma letra e `-` como separador garante que o motor de busca analise as consultas da maneira que você espera. + +### Indexando Documentos +Agora vamos **adicionar documentos ao índice** para que eles se tornem pesquisáveis. + +#### Etapa 3: Adicionando Documentos +```java +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` +O método escaneia a pasta especificada recursivamente e indexa todos os tipos de arquivo suportados. + +### Preparando a Consulta de Busca +Para **escapar caracteres especiais na consulta**, primeiro normalizamos a entrada com base na configuração alfabética, depois adicionamos sequências de escape. + +#### Etapa 4: Modificar Caracteres Especiais +```java +StringBuilder result = new StringBuilder(); +String word = "rock&roll-music"; + +for (int i = 0; i < word.length(); i++) { + char character = word.charAt(i); + CharacterType characterType = index.getDictionaries().getAlphabet().getCharacterType(character); + + if (characterType == CharacterType.Separator) { + result.append(' '); + } else { + result.append(character); + } +} +``` + +#### Etapa 5: Escapar Caracteres Especiais +```java +String specialCharacters = "()\":&|!^~*?"; +for (int i = result.length() - 1; i >= 0; i--) { + char c = result.charAt(i); + if (specialCharacters.indexOf(c) != -1) { + result.insert(i, '\\'); + } +} +String query = result.toString(); +if (query.contains(" ")) { + query = "\"" + query + "\""; +} +``` +Escapar impede que o analisador interprete erroneamente símbolos como operadores. + +### Executando a Busca +Finalmente, execute a consulta contra o índice preparado. + +#### Etapa 6: Executar Busca +```java +import com.groupdocs.search.results.*; + +SearchResult searchResult = index.search(query); +``` +O método `search` retorna um objeto `SearchResult` contendo documentos correspondentes, trechos e pontuações de relevância. + +## Aplicações Práticas + +### Estudo de Caso 1: Sistemas de Gerenciamento de Documentos +Escritórios de advocacia podem localizar rapidamente arquivos de casos indexando PDFs, documentos Word e e‑mails. Ao **melhorar o desempenho de consulta**, os advogados passam menos tempo aguardando resultados e mais tempo revisando o conteúdo. + +### Estudo de Caso 2: Plataformas de E‑commerce +Varejistas online indexam descrições de produtos, especificações e avaliações. Consultas corretamente escapadas permitem que os clientes busquem por frases como `4‑K TV` sem erros, enquanto a execução rápida da consulta mantém a experiência de compra fluida. + +## Considerações de Desempenho e Dicas +- **Atualize o índice** após importações em massa ou grandes atualizações para manter a latência de busca baixa. +- **Alocar memória heap suficiente** (`-Xmx2g` ou superior) para grandes conjuntos de dados. +- **Reutilizar a instância `Index`** em várias buscas ao invés de recriá‑la a cada vez. +- **Perfil de execução da consulta** usando as ferramentas integradas do Java para identificar gargalos. + +## Armadilhas Comuns e Soluções + +| Problema | Por que acontece | Correção | +|----------|------------------|----------| +| Consultas não retornam resultados após adicionar novos arquivos | Índice não atualizado | Chame `index.add(newPath)` ou reconstrua o índice. | +| Erros sobre caracteres inesperados | Caracteres especiais não escapados | Garanta que a lógica de escape da Etapa 5 seja executada antes da busca. | +| Uso elevado de memória | Conjuntos de resultados grandes carregados de uma vez | Itere sobre `searchResult.getDocuments()` de forma preguiçosa ou limite os resultados com `index.search(query, 100)`. | + +## Perguntas Frequentes + +**Q: Como lidar com conjuntos de dados extremamente grandes com GroupDocs.Search?** +A: Use indexação incremental (`index.add`) e agende otimizações periódicas do índice. Implante o índice em armazenamento SSD para I/O mais rápido. + +**Q: O GroupDocs.Search pode ser integrado ao Spring Boot?** +A: Sim. Defina o bean `Index` em uma classe `@Configuration` e injete‑o onde precisar de recursos de busca. + +**Q: Quais caracteres devem ser escapados em uma consulta?** +A: Os caracteres `()":&|!^~*?` precisam de uma barra invertida (`\`) precedendo‑os para serem tratados como literais. + +**Q: Como posso atualizar um índice existente com documentos recém‑carregados?** +A: Chame `index.add("NEW_DOCUMENT_DIRECTORY")`; a biblioteca mesclará novas entradas sem reconstruir todo o índice. + +**Q: O GroupDocs.Search é adequado para cenários de busca em tempo real?** +A: Absolutamente. A biblioteca suporta atualizações incrementais rápidas e consultas de baixa latência, tornando‑a ideal para caixas de busca ao vivo. + +## Recursos +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/) + +--- + +**Última atualização:** 2026-01-21 +**Testado com:** GroupDocs.Search Java 25.4 +**Author:** GroupDocs + +--- \ No newline at end of file diff --git a/content/portuguese/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md b/content/portuguese/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md new file mode 100644 index 00000000..91724636 --- /dev/null +++ b/content/portuguese/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md @@ -0,0 +1,229 @@ +--- +date: '2026-01-21' +description: Aprenda como adicionar a dependência GroupDocs Maven, configurar e sincronizar + uma rede de busca Java e adicionar diretórios ao índice com o GroupDocs.Search. +keywords: +- Java Search Network Configuration +- GroupDocs.Search for Java +- Document Indexing and Retrieval +title: Dependência Maven do GroupDocs – Sincronização de Rede de Busca Java +type: docs +url: /pt/java/search-network/java-groupdocs-search-configuration-sync-guide/ +weight: 1 +--- + +# Dependência Maven do GroupDocs: Configurando e Sincronizando Redes de Busca Java + +Neste guia abrangente, você descobrirá **como adicionar a dependência Maven do GroupDocs** ao seu projeto e, em seguida, configurar uma rede de busca Java robusta usando o GroupDocs.Search. Seja lidando com documentos jurídicos, relatórios financeiros ou artigos acadêmicos, as etapas abaixo ajudarão você a indexar, buscar e manter seus shards sincronizados de forma eficiente. + +## Introdução + +Gerenciar e buscar em coleções massivas de documentos é um desafio diário para muitas organizações. Ao integrar a **dependência Maven do GroupDocs**, você obtém acesso a um motor de indexação poderoso que escala em múltiplos nós. Este tutorial orienta você na configuração da dependência, implantação de nós de rede, adição de diretórios ao índice e sincronização de shards para desempenho ideal. + +### Respostas Rápidas +- **O que é a dependência Maven do GroupDocs?** Um artefato Maven que traz a biblioteca GroupDocs.Search para o seu projeto Java. +- **Por que usar uma rede de busca?** Ela distribui a carga de indexação e consultas entre vários nós, melhorando velocidade e confiabilidade. +- **Como adiciono diretórios ao índice?** Use `IndexingDocuments.addDirectories` no nó mestre. +- **Como sincronizar shards?** Chame `SynchronizeOptions` no `Indexer` de cada nó. +- **Preciso de licença?** Sim, uma licença de teste ou comercial é necessária para uso em produção. + +## O que é a Dependência Maven do GroupDocs? + +A dependência Maven do GroupDocs (`com.groupdocs:groupdocs-search`) empacota todas as classes necessárias para criar índices pesquisáveis, gerenciar nós de rede e executar consultas rápidas. Adicioná‑la ao seu `pom.xml` garante que o Maven baixe os binários corretos e as dependências transitivas. + +## Como Adicionar a Dependência Maven do GroupDocs + +### Configuração Maven + +Adicione o repositório e a dependência ao seu `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +> **Dica:** Mantenha o número da versão atualizado verificando a página oficial de lançamentos. + +Você também pode baixar o JAR diretamente do site oficial: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +## Pré-requisitos + +- **JDK** (11 ou superior) instalado. +- Uma IDE como IntelliJ IDEA ou Eclipse. +- Conhecimento básico de Java, familiaridade com Maven e compreensão dos conceitos de nós de rede. +- Uma licença válida do GroupDocs.Search (teste gratuito ou comercial). + +## Inicialização e Configuração Básicas + +Comece criando um diretório de índice: + +```java +import com.groupdocs.search.SearchIndex; +import com.groupdocs.search.options.IndexingOptions; + +// Create an index in the specified directory +SearchIndex index = new SearchIndex("YOUR_INDEX_DIRECTORY"); +``` + +Esta etapa simples prepara o ambiente para a configuração subsequente da rede. + +## Guia de Implementação + +### Recurso 1: Configuração da Rede de Busca + +#### Visão Geral + +Configurar a rede de busca define os caminhos de arquivos e portas que os nós usarão para se comunicar. + +##### Configurar Caminhos e Portas +```java +import com.groupdocs.search.options.*; +import com.groupdocs.search.scaling.configuring.ConfiguringSearchNetwork; + +// Set custom paths for input/output directories +String basePath = "YOUR_DOCUMENT_DIRECTORY/AdvancedUsage/Scaling/SynchronizingShards/"; +int basePort = 49144; // Adjust if there's a port conflict + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` +O objeto `configuration` agora contém todas as configurações necessárias para sua rede de busca. + +### Recurso 2: Implantação de Nós da Rede de Busca + +#### Visão Geral + +Implante nós para distribuir a carga de trabalho em sua rede. O nó mestre gerencia operações e eventos. + +##### Código de Implantação +```java +import com.groupdocs.search.scaling.*; +import com.groupdocs.search.options.Configuration; + +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +// Retrieve the master node for further operations +SearchNetworkNode masterNode = nodes[0]; +``` + +### Recurso 3: Inscrição em Eventos de Nós da Rede de Busca + +#### Visão Geral + +Escutar eventos permite o tratamento dinâmico de alterações ou atualizações em sua rede. + +##### Implementação da Inscrição +```java +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.scaling.SearchNetworkNodeEvents; + +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Recurso 4: Adicionando Diretórios ao Índice + +#### Visão Geral + +Adicionar diretórios é a etapa central que torna seus documentos pesquisáveis. + +##### Adição de Documentos +```java +import com.groupdocs.search.indexing.IndexingDocuments; +import com.groupdocs.search.scaling.SearchNetworkNode; + +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +``` + +### Recurso 5: Sincronizando Shards no Nó da Rede de Busca + +#### Visão Geral + +A sincronização garante a consistência dos dados em todos os shards. + +##### Código de Sincronização +```java +import com.groupdocs.search.indexing.Indexer; +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.options.SynchronizeOptions; + +SearchNetworkNode node = null; // Assume 'node' is initialized as a SearchNetworkNode + +def synchronizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + SynchronizeOptions options = new SynchronizeOptions(); + indexer.synchronize(options); +} +``` + +### Recurso 6: Fechando Nós da Rede de Busca + +#### Visão Geral + +Fechar os nós corretamente libera recursos e evita vazamentos de memória. + +##### Fechamento do Nó +```java +import com.groupdocs.search.scaling.SearchNetworkNode; + +for (SearchNetworkNode node : nodes) { + node.close(); +} +``` + +## Aplicações Práticas + +1. **Gestão de Documentos Jurídicos** – Recupere rapidamente processos e precedentes. +2. **Manutenção de Registros Financeiros** – Acesse extratos e auditorias em segundos. +3. **Pesquisa Acadêmica** – Busque entre milhares de artigos para encontrar citações relevantes. + +## Considerações de Desempenho + +- **Otimizar Consultas** – Escreva consultas concisas para reduzir o tempo de resposta. +- **Gerenciamento de Memória** – Monitore o uso de heap da JVM; considere ajustes de GC para índices grandes. +- **Estratégia de Escala** – Adicione nós proporcionalmente ao volume de dados e à carga de consultas. + +## Problemas Comuns e Soluções + +| Problema | Causa | Solução | +|----------|-------|----------| +| Nós falham ao conectar | Conflito de porta | Alterar `basePort` para um valor não usado | +| Índice não está sendo atualizado | Falta de inscrição em eventos | Garantir que `SearchNetworkNodeEvents.subscribe(masterNode)` seja chamado | +| Alta latência | Shards insuficientes | Aumentar o número de nós e balancear a distribuição de documentos | + +## Perguntas Frequentes + +**Q: Qual é o principal benefício de usar o GroupDocs.Search?** +A: Ele oferece capacidades de busca rápidas e escaláveis em grandes conjuntos de documentos com configuração mínima. + +**Q: Posso personalizar as configurações dos nós em uma rede de busca?** +A: Sim, você pode definir caminhos, portas e outras opções personalizadas via o objeto `Configuration`. + +**Q: Como adiciono diretórios ao índice após a rede estar em execução?** +A: Chame `IndexingDocuments.addDirectories(masterNode, "caminho")` sempre que precisar indexar novas pastas. + +**Q: Como sincronizar shards quando um novo nó entra na rede?** +A: Use o método `synchronizeShards` mostrado acima no nó recém‑adicionado. + +**Q: Preciso de licença para desenvolvimento?** +A: Uma licença de teste gratuita é suficiente para testes; uma licença comercial é necessária para produção. + +## Conclusão + +Seguindo este guia, você agora sabe **como adicionar a dependência Maven do GroupDocs**, configurar uma rede de busca multi‑nó, indexar diretórios e manter os shards sincronizados. Essas etapas estabelecem a base para uma solução de busca de documentos de alto desempenho que pode crescer conforme as necessidades da sua organização. + +--- + +**Última atualização:** 2026-01-21 +**Testado com:** GroupDocs.Search 25.4 +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/portuguese/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/portuguese/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..038d623e --- /dev/null +++ b/content/portuguese/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,182 @@ +--- +date: '2026-01-21' +description: Aprenda como otimizar shards usando o GroupDocs.Search para Java e como + configurar a rede de busca, realizar pesquisa de texto e lidar com conflitos de + porta. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Como otimizar shards no GroupDocs.Search para Java: um guia abrangente' +type: docs +url: /pt/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# Como Otimizar Shards no GroupDocs.Search para Java: Um Guia Abrangente + +A busca eficiente de documentos é essencial para desenvolvedores e empresas que gerenciam grandes bancos de dados ou que desejam simplificar os processos internos de recuperação de documentos. Se você está se perguntando **como otimizar shards**, este guia mostrará passo a passo como melhorar o desempenho, configurar sua rede de busca e lidar com desafios comuns, como conflitos de porta. **GroupDocs.Search Java** oferece configuração e otimização perfeitas da sua rede de busca, aprimorando tanto o desempenho quanto a experiência do usuário. + +## Respostas Rápidas +- **What is shard optimization?** It reorganizes index data to speed up queries and reduce storage overhead. +- **How to configure a search network?** Define a base directory and port, then deploy nodes using the provided API. index documents in Java?** Add document directories to the master node with `IndexingDocuments.addDirectories`. +- **How to handle port conflicts?** Change the `basePort` variable to an unused port on your machine. + +## Como Configurar a Rede de Busca +Antes de mergulhar em indexação e busca, você precisa de uma base de rede sólida. rede, escolher uma porta e evitar problemas comuns de conflito de porta. + +## Como Indexar Documentos Java +Uma vez que a rede esteja ativa, o próximo passo é alimentá‑la com conteúdo. Mostraremos como adicionar várias pastas de documentos para que o mecanismo possa construir um índice pesquisável. + +## Como Realizar Busca de Texto +Após a indexação, você desejará recuperar informações rapidamente. Esta parte demonstra a maneira maisifique‑se de emando a seguinte configuração ao seu arquivo `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` +Alternativamente, faça o download da versão mais recente em [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Requisitos de Configuração do Ambiente +- Certifique‑se de que seu ambiente de desenvolvimento suporta Java (JDK 8 ou superior). +- Acesso a uma configuração de rede que permita o uso de portas. + +### Pré‑requisitos de Conhecimento +Um entendimento básico de programação Java, incluindo princípios orientados a objetos e tratamento de exceções, será benéfico para este tutorial. + +## Configurando o GroupDocs.Search para Java +Para começar a usar o GroupDocs.Search em seu projeto, siga estes passos: + +1. **Add the Dependency**: As shown above, add the necessary Maven dependency to your project or download directly from the releases page. + +2. **License Acquisition**: + - For a free trial, use the library without restrictions on features but with some usage limitations. + - Obtain a temporary license for full feature access during evaluation by visiting [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/). + - Purchase a full license if you decide to integrate GroupDocs.Search into your production environment. + +3. **Basic Initialization and Setup**: + Initialize the configuration using the `Configuration` class, setting up the base path for documents and specifying a port number: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Guia de Implementação +Agora vamos explorar a implementação dos recursos principais usando GroupDocs.Search Java. + +### Feature: Configuring Search Network +**Overview**: Setting up a search network involves defining your document directory and configuring it with a specific port for communication between nodes. + +#### Step 1: Define Document Directories and Port +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Step 2: Configure Search Network +Create the configuration object using the defined paths: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Feature: Deploying Search Network Nodes +**Overview**: Deploy nodes to handle document searches efficiently across your network. + +#### Step 1: Deploy Nodes Using Configuration +Deploy search network nodes and identify the master node for centralized management: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Feature: Subscribing to Network Node Events +**Overview**: Monitor your search network by subscribing to events that notify you of important changes or actions. + +#### Step 1: Subscribe to Master Node Events +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Feature: Indexing Documents in Network Nodes +**Overview**: Add directories containing documents to the indexing process for efficient searches. + +#### Step 1: Add Document Directories to Indexing Process +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Feature: Text Search in Network Nodes +**Overview**: Execute text searches across all indexed documents within your search network. + +#### Step 1: Perform a Text Search +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Feature: Optimizing Shards +**Overview**: Enhance performance by optimizing shards within the indexer of your search network node. + +#### Step 1: Optimize Indexer Shards +Optimize shards to improve search efficiency (this is where **how to optimize shards** really matters): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Aplicações Práticas +GroupDocs.Search para Java pode ser aplicado em diversos cenários reais: +1. **Enterprise Document Management**: Facilitar a recuperação de documentos em grandes bancos de dados corporativos. +2. **E‑commerce Platforms**: Melhorar as capacidades de busca de produtos usando indexação e recursos de consulta otimizados. +3. **Legal Firms**: Gerenciar e recuperar eficientemente arquivos de casos e documentos de arquivos extensos. +4. **Library Systems**: Simplificar o processo de catalogação integrando-se a sistemas de bibliotecas digitais (CMS)**: Aprimorar a descoberta de conteúdo através de recursos avançados de busca. + +## Considerações resposta das consultas. +- Monitore e gerencie o uso de memória, especialmente em ambientes que lidam com grandes volumes de dados. +- Siga as melhores práticas Java para coleta de lixo e gerenciamento de recursos para manter a eficiência do sistema. + +##ente, você aprendeu como configurar e otimizar uma rede de busca usando GroupDocs.Search para Java. Com essas habilidades, você está preparado para lidar com buscas de documentos eficientes em várias aplicações, aprimorando o desempenho do seu projeto e a experiência do usuário. Para explorar ainda mais as capacidades do GroupDocs.Search, considere integrá‑lo a outros sistemas improves search network performance by. + during setup?** + - Common issues include incorrect port configurations and missing dependencies; ensure you follow the prerequisites accurately. + +## Frequently Asked Questions + +**Q: Como a otimização de shards afeta a velocidade da consulta?** +A: A otimização de shards compacta o índice, reduz a I/O de disco e geralmente resulta em respostas de consulta mais rápidas. + +**Q: É seguro executar `optimizeShards` em um nó ativo?** +A: Sim, a operação foi projetada para ser executada sem tempo de inatividade, mas é recomendável agendá‑la durante períodos de baixo tráfego para índices grandes. + +**Q: Posso personalizar o `OptimizeOptions`?** +A: Absolutamente. Você pode definir parâmetros como ``?** +A: Verifique as permissões do sistema de arquivos, assegure que há espaço em disco suficiente e confirme que nenhum outro processo está bloqueando os arquivos de índice. + +**Q: A otimização de shards também recupera espaço de documentos excluídos?** +A: \ No newline at end of file diff --git a/content/russian/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/russian/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..43819fb1 --- /dev/null +++ b/content/russian/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,210 @@ +--- +date: '2026-01-21' +description: Узнайте, как оптимизировать шарды с помощью GroupDocs.Search для Java, + как настроить поисковую сеть, выполнить текстовый поиск и решить конфликты портов. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Как оптимизировать шарды в GroupDocs.Search для Java: Полное руководство' +type: docs +url: /ru/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# Как оптимизировать шарды в GroupDocs.Search для Java: Полное руководство + +Эффективный поиск по документам необходим разработчикам и компаниям, управляющим большими базами данных или желающим упростить внутренние процессы извлечения документов. Если вы задаётесь вопросом **как оптимизировать шарды**, это руководство проведёт вас через шаги по повышению производительности, настройке поисковой сети и решению распространённых проблем, таких как конфликты портов. **GroupDocs.Search Java** обеспечивает бесшовную конфигурацию и оптимизацию вашей поисковой сети, улучшая как производительность, так и пользовательский опыт. + +## Быстрые ответы +- **Что такое оптимизация шардов?** Она реорганизует данные индекса, ускоряя запросы и уменьшая нагрузку на хранилище. +- **Как настроить поисковую сеть?** Определите базовый каталог и порт, затем разверните узлы с помощью предоставленного API. +- **Как выполнить текстовый поиск?** Используйте `TextSearchInNetwork.searchAll` с вашей строкой запроса. +- **Как индексировать документы на Java?** Добавьте каталоги документов к главному узлу с помощью `IndexingDocuments.addDirectories`. +- **Как решить конфликты портов?** Измените переменную `basePort` на неиспользуемый порт на вашей машине. + +## Как настроить поисковую сеть +Прежде чем приступить к индексации и поиску, вам нужна надёжная сетёвая основа. В этом разделе объясняются шаги по настройке сети, выбору порта и избежанию типичных проблем с конфликтом портов. + +## Как индексировать документы на Java +После того как сеть запущена, следующий шаг — заполнить её контентом. Мы покажем, как добавить несколько папок с документами, чтобы движок смог построить индекс для поиска. + +## Как выполнить текстовый поиск +После индексации вы захотите быстро получать информацию. Эта часть демонстрирует самый простой способ выполнить текстовый запрос на всех узлах. + +## Как решить конфликты портов +Если порт по умолчанию (`49132`) уже используется, просто измените значение `basePort` на свободный порт и перезапустите конфигурацию. Это предотвратит ошибки запуска и обеспечит стабильность сети. + +## Предварительные требования +Прежде чем начать, убедитесь, что у вас есть следующие предварительные условия: + +### Требуемые библиотеки, версии и зависимости +Чтобы реализовать это решение, включите библиотеку GroupDocs.Search, используя Maven, добавив следующую конфигурацию в ваш файл `pom.xml`: + +```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 (JDK 8 или новее). +- Доступ к сетевой конфигурации, позволяющей использовать порты. + +### Требования к знаниям +Базовое понимание программирования на Java, включая объектно‑ориентированные принципы и обработку исключений, будет полезным для этого руководства. + +## Настройка GroupDocs.Search для Java +Чтобы начать использовать GroupDocs.Search в вашем проекте, выполните следующие шаги: + +1. **Добавьте зависимость**: Как показано выше, добавьте необходимую Maven‑зависимость в ваш проект или скачайте её напрямую со страницы релизов. +2. **Получение лицензии**: + - Для бесплатного пробного периода используйте библиотеку без ограничений функций, но с некоторыми ограничениями по использованию. + - Получите временную лицензию для полного доступа к функциям во время оценки, посетив [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/). + - Приобретите полную лицензию, если решите интегрировать GroupDocs.Search в производственную среду. +3. **Базовая инициализация и настройка**: + Инициализируйте конфигурацию с помощью класса `Configuration`, задав базовый путь к документам и номер порта: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Руководство по реализации +Теперь рассмотрим реализацию ключевых функций с использованием GroupDocs.Search Java. + +### Функция: Настройка поисковой сети +**Обзор**: Настройка поисковой сети включает определение каталога документов и конфигурацию конкретного порта для связи между узлами. + +#### Шаг 1: Определите каталоги документов и порт +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Шаг 2: Настройте поисковую сеть +Создайте объект конфигурации, используя определённые пути: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Функция: Развёртывание узлов поисковой сети +**Обзор**: Развёртывание узлов позволяет эффективно обрабатывать поисковые запросы по всей сети. + +#### Шаг 1: Разверните узлы с помощью конфигурации +Разверните узлы поисковой сети и определите главный узел для централизованного управления: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Функция: Подписка на события узлов сети +**Обзор**: Мониторьте вашу поисковую сеть, подписываясь на события, которые уведомляют о важных изменениях или действиях. + +#### Шаг 1: Подпишитесь на события главного узла +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Функция: Индексация документов в узлах сети +**Обзор**: Добавьте каталоги с документами в процесс индексации для эффективного поиска. + +#### Шаг 1: Добавьте каталоги документов в процесс индексации +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Функция: Текстовый поиск в узлах сети +**Обзор**: Выполняйте текстовые поиски по всем проиндексированным документам внутри вашей поисковой сети. + +#### Шаг 1: Выполните текстовый поиск +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Функция: Оптимизация шардов +**Обзор**: Повышайте производительность, оптимизируя шарды внутри индексатора вашего узла поисковой сети. + +#### Шаг 1: Оптимизируйте шарды индексатора +Оптимизируйте шарды для улучшения эффективности поиска (здесь и проявляется **как оптимизировать шарды**): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Практические применения +GroupDocs.Search для Java может быть использован в различных реальных сценариях: +1. **Корпоративное управление документами**: Обеспечьте быстрый поиск по большим корпоративным базам данных. +2. **Платформы электронной коммерции**: Улучшите возможности поиска товаров с помощью оптимизированного индексирования и запросов. +3. **Юридические фирмы**: Эффективно управляйте и извлекайте судебные дела и документы из обширных архивов. +4. **Библиотечные системы**: Упростите процесс каталогизации, интегрируя с цифровыми библиотеками для быстрых поисков. +5. **Системы управления контентом (CMS)**: Повышайте обнаруживаемость контента через расширенные функции поиска. + +## Соображения по производительности +Чтобы обеспечить оптимальную работу вашего внедрения GroupDocs.Search: +- Регулярно оптимизируйте шарды для снижения времени отклика запросов. +- Следите за использованием памяти, особенно в средах, работающих с большими наборами данных. +- Применяйте лучшие практики Java для сборки мусора и управления ресурсами, поддерживая эффективность системы. + +## Заключение +Следуя этому полному руководству, вы научились настраивать и оптимизировать поисковую сеть с помощью GroupDocs.Search для Java. Обладая этими навыками, вы теперь способны выполнять эффективный поиск по документам в различных приложениях, повышая производительность проекта и пользовательский опыт. Чтобы дальше исследовать возможности GroupDocs.Search, рассмотрите интеграцию с другими системами или изучите дополнительные функции, описанные в их документации. + +## Раздел FAQ +1. **Что такое оптимизация шардов?** + - Оптимизация шардов улучшает производительность поисковой сети, более эффективно организуя данные внутри каждого шарда. +2. **Как решить конфликты портов при настройке поисковой сети?** + - Измените переменную `basePort` на свободный порт в вашей системе и перезапустите процесс настройки. +3. **Можно ли интегрировать GroupDocs.Search в существующие Java‑приложения?** + - Да, интеграция происходит без проблем, достаточно добавить зависимость библиотеки в ваш проект. +4. **Какие распространённые проблемы возникают при установке?** + - Часто встречаются неверные настройки портов и отсутствие зависимостей; убедитесь, что вы точно следуете предварительным требованиям. + +## Часто задаваемые вопросы + +**Вопрос: Как оптимизация шардов влияет на скорость запросов?** +Ответ: Оптимизация шардов уплотняет индекс, уменьшает ввод‑вывод с диска и обычно приводит к более быстрым ответам на запросы. + +**Вопрос: Безопасно ли запускать `optimizeShards` на работающем узле?** +Ответ: Да, операция спроектирована так, чтобы выполняться без простоя, однако рекомендуется планировать её на периоды низкой нагрузки для больших индексов. + +**Вопрос: Можно ли настроить `OptimizeOptions`?** +Ответ: Конечно. Вы можете задать параметры, такие как `maxSegmentSize` или `mergeFactor`, для тонкой настройки процесса оптимизации. + +**Вопрос: Что делать, если во время оптимизации возникает `IOException`?** +Ответ: Проверьте права доступа к файловой системе, убедитесь, что достаточно свободного места на диске, и что ни один другой процесс не блокирует файлы индекса. + +**Вопрос: Оптимизация шардов также освобождает место, занятое удалёнными документами?** +Ответ: Да, оптимизатор объединяет сегменты и удаляет «могильные» записи, освобождая пространство, занятое удалёнными документами. + +--- + +**Последнее обновление:** 2026-01-21 +**Тестировано с:** GroupDocs.Search 25.4 для Java +**Автор:** GroupDocs \ No newline at end of file diff --git a/content/spanish/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/spanish/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md new file mode 100644 index 00000000..2e824411 --- /dev/null +++ b/content/spanish/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -0,0 +1,211 @@ +--- +date: '2026-01-21' +description: Aprenda cómo mejorar el rendimiento de las consultas y agregar documentos + al índice mientras escapa correctamente los caracteres especiales en la consulta + usando GroupDocs.Search Java. +keywords: +- GroupDocs.Search Java +- document index optimization +- search query performance +title: 'Mejora el rendimiento de las consultas con GroupDocs.Search Java: Optimiza + el índice y la búsqueda' +type: docs +url: /es/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/ +weight: 1 +--- + +# Mejora el Rendimiento de las Consultas con GroupDocs.Search Java: Optimiza el Índice y la Búsqueda + +Gestionar eficientemente una colección masiva de documentos comienza con **mejorar el rendimiento de las consultas**. En este tutorial descubrirás cómo crear y configurar un índice de alto rendimiento, **añadir documentos al índice**, y escapar correctamente los **caracteres especiales en la consulta** para que las búsquedas sean rápidas y devuelvan resultados precisos. Ya sea que estés construyendo una base de conocimiento corporativa o un catálogo de comercio electrónico buscable, dominar estos pasos mantendrá tu aplicación receptiva bajo carga pesada. + +## Respuestas rápidas +- **¿Cuál es el objetivo principal?** Mejorar el rendimiento de las consultas afinando el índice y el manejo de consultas. +- **¿Qué biblioteca se utiliza?** GroupDocs.Search para Java. +- **¿Necesito una licencia?** Una prueba gratuita o una licencia temporal es suficiente para desarrollo; se requiere una licencia completa para producción. +- **¿Cómo añado documentos?** Usa `index.add("YOUR_DOCUMENT_DIRECTORY")` para cargar archivos en bloque. +- **¿Cómo se manejan los caracteres especiales?** Configura el diccionario alfabético y escapa caracteres como `()":&|!^~*?` antes de ejecutar la búsqueda. + +## ¿Qué significa “mejorar el rendimiento de las consultas”? +Mejorar el rendimiento de las consultas implica reducir el tiempo que tarda una solicitud de búsqueda en atravesar el índice, coincidir términos y devolver resultados. Al configurar correctamente el índice y preparar consultas que se alineen con esa configuración, eliminas procesamientos innecesarios y logras tiempos de respuesta más rápidos. + +## ¿Por qué usar GroupDocs.Search Java para búsquedas de alto rendimiento? +- **Indexación escalable** – Maneja millones de documentos con actualizaciones incrementales. +- **Amplio soporte de idiomas** – Analizadores integrados para muchos alfabetos y caracteres especiales. +- **Fácil integración** – Funciona con cualquier aplicación basada en Java, desde servicios Spring Boot hasta herramientas de escritorio. + +## Requisitos previos + +Antes de profundizar, asegúrate de tener lo siguiente listo: + +### Bibliotecas y dependencias requeridas +Para usar GroupDocs.Search en un proyecto Maven, incluye las siguientes configuraciones: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Configuración del entorno +- JDK 8 o superior instalado y configurado. +- IDE como IntelliJ IDEA o Eclipse. + +### Conocimientos previos +- Programación básica en Java. +- Familiaridad con Maven. +- Comprensión de conceptos de gestión documental. + +## Configuración de GroupDocs.Search para Java + +### 1. Instalar vía Maven o descarga directa +Añade el fragmento XML anterior a tu `pom.xml`. Si prefieres un enfoque manual, descarga la biblioteca desde el sitio oficial: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### 2. Obtener una licencia +Puedes obtener una prueba gratuita o una licencia temporal aquí: + +[GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license) + +### 3. Inicialización básica +Crea un objeto `Index` que apunte a una carpeta donde se almacenarán los archivos del índice: + +```java +import com.groupdocs.search.*; + +public class SearchInitialization { + public static void main(String[] args) { + Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); + System.out.println("GroupDocs.Search initialized successfully."); + } +} +``` + +## Guía de implementación + +### Creación y configuración de un índice +Configurar el diccionario alfabético te permite decidir cómo se tratan los caracteres especiales, lo cual es esencial para **mejorar el rendimiento de las consultas**. + +#### Paso 1: Inicializar el índice +```java +Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); +``` + +#### Paso 2: Configurar tipos de caracteres +```java +index.getDictionaries().getAlphabet() + .setRange(new char[] {'&'}, CharacterType.Letter) + .setRange(new char[] {'-'}, CharacterType.Separator); +``` +Tratar `&` como una letra y `-` como separador garantiza que el motor de búsqueda analice las consultas de la manera esperada. + +### Indexación de documentos +Ahora vamos a **añadir documentos al índice** para que sean buscables. + +#### Paso 3: Añadir documentos +```java +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` +El método escanea la carpeta especificada de forma recursiva e indexa cada tipo de archivo compatible. + +### Preparación de la consulta de búsqueda +Para **escapar los caracteres especiales en la consulta**, primero normalizamos la entrada según la configuración del alfabeto y luego añadimos secuencias de escape. + +#### Paso 4: Modificar caracteres especiales +```java +StringBuilder result = new StringBuilder(); +String word = "rock&roll-music"; + +for (int i = 0; i < word.length(); i++) { + char character = word.charAt(i); + CharacterType characterType = index.getDictionaries().getAlphabet().getCharacterType(character); + + if (characterType == CharacterType.Separator) { + result.append(' '); + } else { + result.append(character); + } +} +``` + +#### Paso 5: Escapar caracteres especiales +```java +String specialCharacters = "()\":&|!^~*?"; +for (int i = result.length() - 1; i >= 0; i--) { + char c = result.charAt(i); + if (specialCharacters.indexOf(c) != -1) { + result.insert(i, '\\'); + } +} +String query = result.toString(); +if (query.contains(" ")) { + query = "\"" + query + "\""; +} +``` +Escapar evita que el analizador interprete erróneamente los símbolos como operadores. + +### Ejecución de la búsqueda +Finalmente, ejecuta la consulta contra el índice preparado. + +#### Paso 6: Ejecutar la búsqueda +```java +import com.groupdocs.search.results.*; + +SearchResult searchResult = index.search(query); +``` +El método `search` devuelve un objeto `SearchResult` que contiene los documentos coincidentes, fragmentos y puntuaciones de relevancia. + +## Aplicaciones prácticas + +### Estudio de caso 1: Sistemas de gestión documental +Los despachos de abogados pueden localizar rápidamente expedientes al indexar PDFs, documentos Word y correos electrónicos. Al **mejorar el rendimiento de las consultas**, los abogados pasan menos tiempo esperando resultados y más tiempo revisando el contenido. + +### Estudio de caso 2: Plataformas de comercio electrónico +Los minoristas en línea indexan descripciones de productos, especificaciones y reseñas. Las consultas correctamente escapadas permiten a los clientes buscar frases como `4‑K TV` sin errores, mientras que la ejecución rápida de consultas mantiene una experiencia de compra fluida. + +## Consideraciones de rendimiento y consejos + +- **Actualiza el índice** después de importaciones masivas o grandes actualizaciones para mantener baja la latencia de búsqueda. +- **Asigna suficiente memoria heap** (`-Xmx2g` o superior) para conjuntos de datos extensos. +- **Reutiliza la instancia `Index`** en múltiples búsquedas en lugar de crearla cada vez. +- **Perfila la ejecución de consultas** usando las herramientas integradas de Java para identificar cuellos de botella. + +## Problemas comunes y soluciones + +| Problema | Por qué ocurre | Solución | +|----------|----------------|----------| +|Path)` o reconstruye el índice. | +| Los caracteres especiales no están escapados | Asegúrate de que la lógica de escape del Paso ?** +R: Usa la indexación incremental (`index.add`) y programa optimizaciones periódicas del índice. Despliega el índice en almacenamiento SSD para I/O más rápido. + +**P: ¿Se puede integrar GroupDocs.Search con Spring Boot?** +R: Sí. Define el bean `Index` en una clase `@Configuration` e inyecta donde necesites capacidades de búsqueda. + +**P: ¿Qué caracteres deben escaparse en una consulta?** +R: Los caracteres `()":&|!^~*?` requieren una barra invertida (`\`) precedente para ser tratados como literales. + +**P: ¿Cómo actualizo un índice existente con documentos recién subidos?** +R: Llama a `index.add("NEW_DOCUMENT_DIRECTORY")`; la biblioteca fusionará las nuevas entradas sin reconstruir todo el índice. + +**P: ¿GroupDocs.Search es adecuado para escenarios de búsqueda en tiempo real?** +R: Absolutamente. La biblioteca soporta actualizaciones incrementales rápidas y consultas de baja latencia, lo que la hace ideal para cajas de búsqueda en vivo. + +## Recursos +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/) + +--- + +**Última actualización:** 2026-01- \ No newline at end of file diff --git a/content/spanish/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md b/content/spanish/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md new file mode 100644 index 00000000..13e53131 --- /dev/null +++ b/content/spanish/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md @@ -0,0 +1,215 @@ +--- +date: '2026-01-21' +description: Aprende cómo agregar la dependencia de GroupDocs Maven, configurar y + sincronizar una red de búsqueda Java, y añadir directorios al índice con GroupDocs.Search. +keywords: +- Java Search Network Configuration +- GroupDocs.Search for Java +- Document Indexing and Retrieval +title: Dependencia Maven de GroupDocs – Sincronización de Red de Búsqueda Java +type: docs +url: /es/java/search-network/java-groupdocs-search-configuration-sync-guide/ +weight: 1 +--- + +# Dependencia Maven de GroupDocs: Configuración y Sincronización de Redes de Búsqueda Java + +En esta guía completa descubrirás **cómo agregar la dependencia Maven de GroupDocs** a tu proyecto y luego configurar una robusta red de búsqueda Java usando GroupDocs.Search. Ya sea que estés manejando informes legales, reportes financieros o trabajos académicos, los pasos a continuación te ayudarán a indexar, buscar y mantener tus shards sincronizados de manera eficiente. + +## Introducción + +Gestionar y buscar en colecciones masivas de documentos es un desafío diario para muchas organizaciones. Al integrar la **dependencia Maven de GroupDocs**, obtienes acceso a un motor de indexación potente que escala a través de múltiples nodos. Este tutorial te guía paso a paso para configurar la dependencia, desplegar nodos de red, agregar directorios al índice y sincronizar shards para un rendimiento óptimo. + +### Respuestas rápidas +- **¿Qué es la dependencia Maven de GroupDocs?** Un artefacto Maven que incorpora la biblioteca GroupDocs.Search en tu proyecto Java. +- **¿Por qué usar una red de búsqueda?** Distribuye la carga de indexación y consultas entre múltiples nodos, mejorando la velocidad y la fiabilidad. +- **¿Cómo agrego directorios al índice?** Usa `IndexingDocuments.addDirectories` en el nodo maestro. +- **¿Cómo sincronizar shards?** Llama a `SynchronizeOptions` en el `Indexer` de cada nodo. +- **¿Necesito una licencia?** Sí, se requiere una licencia de prueba o comercial para uso en producción. + +## ¿Qué es la dependencia Maven de GroupDocs? + +La dependencia Maven de GroupDocs (`com.groupdocs:groupdocs-search`) empaqueta todas las clases que necesitas para crear índices buscables, gestionar nodos de red y ejecutar consultas rápidas. Añadirla a tu `pom.xml` garantiza que Maven descargue los binarios correctos y sus dependencias transitivas. + +## Cómo agregar la dependencia Maven de GroupDocs + +### Configuración de Maven + +Agrega el repositorio y la dependencia a tu `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +> **Consejo profesional:** Mantén el número de versión actualizado consultando la página oficial de lanzamientos. + +También puedes descargar el JAR directamente desde el sitio oficial: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +## Requisitos previos + +- **JDK** (11 o más reciente) instalado. +- Un IDE como IntelliJ IDEA o Eclipse. +- Conocimientos básicos de Java, familiaridad con Maven y comprensión de los conceptos de nodos de red. +- Una licencia válida de GroupDocs.Search (prueba gratuita o comercial). + +## Inicialización y configuración básica + +Comienza creando un directorio de índice: + +```java +import com.groupdocs.search.SearchIndex; +import com.groupdocs.search.options.IndexingOptions; + +// Create an index in the specified directory +SearchIndex index = new SearchIndex("YOUR_INDEX_DIRECTORY"); +``` + +Este paso sencillo prepara el entorno para la configuración de red posterior. + +## Guía de implementación + +### Función 1: Configuración de la Red de Búsqueda + +#### Visión general + +Configurar la red de búsqueda establece las rutas de archivos y los puertos que los nodos usarán para comunicarse. + +##### Configurar rutas y puertos +```java +import com.groupdocs.search.options.*; +import com.groupdocs.search.scaling.configuring.ConfiguringSearchNetwork; + +// Set custom paths for input/output directories +String basePath = "YOUR_DOCUMENT_DIRECTORY/AdvancedUsage/Scaling/SynchronizingShards/"; +int basePort = 49144; // Adjust if there's a port conflict + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` +El objeto `configuration` ahora contiene todos los ajustes necesarios para tu red de búsqueda. + +### Función 2: Despliegue de Nodos de la Red de Búsqueda + +#### Visión general + +Despliega nodos para distribuir la carga de trabajo a través de tu red. El nodo maestro gestiona operaciones y eventos. + +##### Código de despliegue +```java +import com.groupdocs.search.scaling.*; +import com.groupdocs.search.options.Configuration; + +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +// Retrieve the master node for further operations +SearchNetworkNode masterNode = nodes[0]; +``` + +### Función 3: Suscripción a Eventos de Nodos de la Red de Búsqueda + +#### Visión general + +Escuchar eventos permite manejar dinámicamente cambios o actualizaciones en tu red. + +##### Implementación de suscripción +```java +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.scaling.SearchNetworkNodeEvents; + +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Función 4: Agregar Directorios al Índice + +#### Visión general + +Agregar directorios es el paso central que hace que tus documentos sean buscables. + +##### Adición de documentos +```java +import com.groupdocs.search.indexing.IndexingDocuments; +import com.groupdocs.search.scaling.SearchNetworkNode; + +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +``` + +### Función 5: Sincronización de Shards en el Nodo de la Red de Búsqueda + +#### Visión general + +La sincronización garantiza la consistencia de datos entre todos los shards. + +##### Código de sincronización +```java +import com.groupdocs.search.indexing.Indexer; +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.options.SynchronizeOptions; + +SearchNetworkNode node = null; // Assume 'node' is initialized as a SearchNetworkNode + +def synchronizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + SynchronizeOptions options = new SynchronizeOptions(); + indexer.synchronize(options); +} +``` + +### Función 6: Cierre de Nodos de la Red de Búsqueda + +#### Visión general + +Cerrar correctamente los nodos libera recursos y previene fugas de memoria. + +##### Cierre del nodo +```java +import com.groupdocs.search.scaling.SearchNetworkNode; + +for (SearchNetworkNode node : nodes) { + node.close(); +} +``` + +## Aplicaciones prácticas + +1. **Gestión de documentos legales** – Recupera rápidamente expedientes y precedentes. +2. **Mantenimiento de registros financieros** – Accede a estados y auditorías en segundos. +3. **Investigación académica** – Busca entre miles de artículos para encontrar citas relevantes. + +## Consideraciones de rendimiento + +- **Optimizar consultas** – Escribe consultas concisas para reducir el tiempo de respuesta. +- **Gestión de memoria** – Monitorea el uso del heap de JVM; considera ajustar el GC para índices grandes. +- carga y soluciones + +| Problema | Causa | Solución | +|----------|-------|----------| +| Los nodos no pueden conectarse | Conflicto de puerto | Cambiar `basePort` a un valor no usado | +| El índice no se actualiza | Falta suscripción a eventos | Asegúrate de que se llame a `SearchNetworkNodeEvents.subscribe insuficientes | Incrementa el número de nodos y equ personalizadas:Node, "path")` siempre que necesites indexar nuevas carpetas. + +**Q: ¿Cómo sincronizar shards cuando un nuevo nodo se une a la red?** +A: Usa el método `synchronizeShards` mostrado arriba en el nodo recién añadido. + +**Q: ¿Necesito una licencia para desarrollo?** +A: Una licencia de prueba gratuita es suficiente para pruebas; se requiere una licencia comercial para producción. + +## Conclusión + +Siguiendo esta guía ahora sabes cómo **agregar la dependencia Maven de GroupDocs**, configurar una red de búsqueda multi‑nodo, indexar directorios y mantener los shards sincronizados. Estos pasos sientan las bases para una solución de búsqueda de documentos de alto rendimiento que puede crecer con las necesidades de tu organización. + +--- + +**Última actualización:** 2026-01-21 +**Probado con:** GroupDocs.Search 25.4 +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/spanish/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/spanish/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..c87ffb57 --- /dev/null +++ b/content/spanish/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,213 @@ +--- +date: '2026-01-21' +description: Aprenda a optimizar fragmentos usando GroupDocs.Search para Java, cómo + configurar la red de búsqueda, realizar búsquedas de texto y manejar conflictos + de puertos. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Cómo optimizar fragmentos en GroupDocs.Search para Java: una guía completa' +type: docs +url: /es/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# Cómo Optimizar Shards en GroupDocs.Search para Java: Una Guía Integral + +La búsqueda eficiente de documentos es esencial para desarrolladores y empresas que gestionan bases de datos grandes o que buscan optimizar los procesos internos de recuperación de documentos. Si te preguntas **cómo optimizar shards**, esta guía te mostrará los pasos para mejorar el rendimiento, configurar tu red de búsqueda y manejar desafíos comunes como los conflictos de puertos. **GroupDocs.Search Java** ofrece una configuración y optimización sin problemas de tu red de búsqueda, mejorando tanto el rendimiento como la experiencia del usuario. + +## Respuestas Rápidas +- **¿Qué es la optimización de shards?** Reorganiza los datos del índice para acelerar las consultas y reducir la sobrecarga de almacenamiento. +- **¿Cómo configurar una red de búsqueda?** Define un directorio base y un puerto, luego despliega los nodos usando la API proporcionada. +- **¿Cómo realizar una búsqueda de texto?** Usa `TextSearchInNetwork.searchAll` con tu cadena de consulta. +- **¿Cómo indexar documentos en Java?** Añade directorios de documentos al nodo maestro con `IndexingDocuments.addDirectories`. +- **¿Cómo manejar conflictos de puertos?** Cambia la variable `basePort` a un puerto no usado en tu máquina. + +## Cómo Configurar la Red de Búsqueda +Antes de sumergirte en la indexación y la búsqueda, necesitas una base de red sólida. Esta sección explica los pasos para configurar la red, elegir un puerto y evitar problemas comunes de conflicto de puertos. + +## Cómo Indexar Documentos en Java +Una vez que la red está en funcionamiento, el siguiente paso es alimentarla con contenido. Te mostraremos cómo agregar múltiples carpetas de documentos para que el motor pueda crear un índice buscable. + +## Cómo Realizar una Búsqueda de Texto +Después de la indexación, querrás recuperar información rápidamente. Esta parte demuestra la forma más sencilla de ejecutar una consulta de texto en todos los nodos. + +## Cómo Manejar Conflictos de Puertos +Si el puerto predeterminado (`49132`) ya está en uso, simplemente cambia el valor de `basePort` a un puerto libre y reinicia la configuración. Esto evita errores de inicio y mantiene tu red estable. + +## Prerrequisitos +Antes de comenzar, asegúrate de tener los siguientes prerrequisitos: + +### Bibliotecas, Versiones y Dependencias Requeridas +Para implementar esta solución, incluye la biblioteca GroupDocs.Search usando Maven añadiendo la siguiente configuración a tu archivo `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` +Alternativamente, descarga la última versión desde [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Requisitos de Configuración del Entorno +- Asegúrate de que tu entorno de desarrollo soporte Java (JDK 8 o superior). +- Acceso a una configuración de red que permita el uso de puertos. + +### Conocimientos Previos +Una comprensión básica de la programación en Java, incluidos los principios orientados a objetos y el manejo de excepciones, será útil para este tutorial. + +## Configuración de GroupDocs.Search para Java +Para comenzar a usar GroupDocs.Search en tu proyecto, sigue estos pasos: + +1. **Agregar la Dependencia**: Como se muestra arriba, agrega la dependencia Maven necesaria a tu proyecto o descárgala directamente desde la página de releases. +2. **Adquisición de Licencia**: + - Para una prueba gratuita, usa la biblioteca sin restricciones de funciones pero con algunas limitaciones de uso. + - Obtén una licencia temporal para acceso completo a funciones durante la evaluación visitando [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/). + - Compra una licencia completa si decides integrar GroupDocs.Search en tu entorno de producción. +3. **Inicialización y Configuración Básica**: + Inicializa la configuración usando la clase `Configuration`, estableciendo la ruta base para los documentos y especificando un número de puerto: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Guía de Implementación +Ahora exploremos la implementación de características clave usando GroupDocs.Search Java. + +### Característica: Configuración de la Red de Búsqueda +**Visión General**: Configurar una red de búsqueda implica definir tu directorio de documentos y configurarlo con un puerto específico para la comunicación entre nodos. + +#### Paso 1: Definir Directorios de Documentos y Puerto +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Paso 2: Configurar la Red de Búsqueda +Crea el objeto de configuración usando las rutas definidas: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Característica: Despliegue de Nodos de la Red de Búsqueda +**Visión General**: Despliega nodos para manejar búsquedas de documentos de manera eficiente en toda tu red. + +#### Paso 1: Desplegar Nodos Usando la Configuración +Despliega los nodos de la red de búsqueda e identifica el nodo maestro para la gestión centralizada: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Característica: Suscripción a Eventos de Nodos de la Red +**Visión General**: Monitorea tu red de búsqueda suscribiéndote a eventos que te notifiquen sobre cambios o acciones importantes. + +#### Paso 1: Suscribirse a Eventos del Nodo Maestro +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Característica: Indexación de Documentos en Nodos de la Red +**Visión General**: Añade directorios que contengan documentos al proceso de indexación para búsquedas eficientes. + +#### Paso 1: Añadir Directorios de Documentos al Proceso de Indexación +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Característica: Búsqueda de Texto en Nodos de la Red +**Visión General**: Ejecuta búsquedas de texto en todos los documentos indexados dentro de tu red de búsqueda. + +#### Paso 1: Realizar una Búsqueda de Texto +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Característica: Optimización de Shards +**Visión General**: Mejora el rendimiento optimizando los shards dentro del indexador de tu nodo de la red de búsqueda. + +#### Paso 1: Optimizar Shards del Indexador +Optimiza los shards para mejorar la eficiencia de búsqueda (aquí es donde realmente importa **cómo optimizar shards**): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Aplicaciones Prácticas +GroupDocs.Search para Java puede aplicarse en varios escenarios del mundo real: +1. **Gestión Documental Empresarial**: Facilita la recuperación de documentos en grandes bases de datos corporativas. +2. **Plataformas de Comercio Electrónico**: Mejora las capacidades de búsqueda de productos usando indexación y consultas optimizadas. +3. **Despachos Jurídicos**: Gestiona y recupera eficientemente expedientes y documentos de archivos extensos. +4. **Sistemas Bibliotecarios**: Agiliza el proceso de catalogación integrándose con sistemas de bibliotecas digitales para búsquedas rápidas. +5. **Sistemas de Gestión de Contenidos (CMS)**: Mejora la descubribilidad de contenido mediante capacidades avanzadas de búsqueda. + +## Consideraciones de Rendimiento +Para garantizar un rendimiento óptimo de tu implementación de GroupDocs.Search: +- Optimiza los shards regularmente para reducir los tiempos de respuesta de las consultas. +- Monitorea y gestiona el uso de memoria, especialmente en entornos que manejan conjuntos de datos grandes. +- Sigue las mejores prácticas de Java para la recolección de basura y la gestión de recursos para mantener la eficiencia del sistema. + +## Conclusión +Al seguir esta guía integral, has aprendido a configurar y optimizar una red de búsqueda usando GroupDocs.Search para Java. Con estas habilidades, ahora estás preparado para manejar búsquedas de documentos eficientes en diversas aplicaciones, mejorando el rendimiento de tu proyecto y la experiencia del usuario. Para explorar más a fondo las capacidades de GroupDocs.Search, considera integrarlo con otros sistemas o explorar características adicionales disponibles en su documentación. + +## Sección de Preguntas Frecuentes +1. **¿Qué es la optimización de shards?** + - La optimización de shards mejora el rendimiento de la red de búsqueda organizando los datos de manera más eficiente dentro de cada shard. +2. **¿Cómo manejo los conflictos de puertos al configurar una red de búsqueda?** + - Cambia la variable `basePort` a un puerto no usado en tu sistema y reinicia el proceso de configuración. +3. **¿Puede integrarse GroupDocs.Search con aplicaciones Java existentes?** + - Sí, puede integrarse sin problemas añadiendo la dependencia de la biblioteca a tu proyecto. +4. **¿Cuáles son algunos problemas comunes durante la configuración?** + - Los problemas comunes incluyen configuraciones de puertos incorrectas y dependencias faltantes; asegúrate de seguir los prerrequisitos con precisión. + +## Preguntas Frecuentes + +**P: ¿Cómo afecta la optimización de shards a la velocidad de consulta?** +R: Optimizar los shards compacta el índice, reduce I/O de disco y, por lo general, produce respuestas de consulta más rápidas. + +**P: ¿Es seguro ejecutar `optimizeShards` en un nodo activo?** +R: Sí, la operación está diseñada para ejecutarse sin tiempo de inactividad, aunque es recomendable programarla durante períodos de bajo tráfico para índices grandes. + +**P: ¿Puedo personalizar `OptimizeOptions`?** +R: Absolutamente. Puedes establecer parámetros como `maxSegmentSize` o `mergeFactor` para afinar el proceso de optimización. + +**P: ¿Qué debo hacer si encuentro una `IOException` durante la optimización?** +R: Verifica los permisos del sistema de archivos, asegura suficiente espacio en disco y confirma que ningún otro proceso esté bloqueando los archivos del índice. + +**P: ¿La optimización de shards también recupera espacio de documentos eliminados?** +R: Sí, el optimizador combina segmentos y elimina los tombstones, liberando el espacio ocupado por documentos borrados. + +--- + +**Última actualización:** 2026-01-21 +**Probado con:** GroupDocs.Search 25.4 para Java +**Autor:** GroupDocs + +--- \ No newline at end of file diff --git a/content/swedish/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/swedish/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md new file mode 100644 index 00000000..b525c176 --- /dev/null +++ b/content/swedish/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -0,0 +1,206 @@ +--- +date: '2026-01-21' +description: Lär dig hur du förbättrar frågeprestanda och lägger till dokument i indexet + samtidigt som du korrekt escapar specialtecken i frågor med GroupDocs.Search Java. +keywords: +- GroupDocs.Search Java +- document index optimization +- search query performance +title: 'Förbättra frågeprestanda med GroupDocs.Search Java: Optimera index och sökning' +type: docs +url: /sv/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/ +weight: 1 +--- + +# Förbättra frågeprestanda med GroupDocs.Search Java: Optimera index & sökning + +Att effektivt hantera en massiv samling dokument börjar med **förbättra frågeprestanda**. I den här handledningen kommer du att upptäcka hur du skapar och konfigurerar ett högpresterande index, **lägger till dokument i index**, och korrekt **escapar specialtecken i fråga** så att sökningar körs snabbt och returnerar korrekta resultat. Oavsett om du bygger en företagskunskapsbas eller en sökbar e‑handelskatalog, kommer behärskning av dessa steg att hålla din applikation responsiv under tung belastning. + +## Snabba svar +- **Vad är huvudmålet?** Förbättra frågeprestanda genom att finjustera indexet och frågehanteringen. +- **Vilket bibliotek används?** GroupDocs.Search for Java. +- **Behöver jag en licens?** En gratis provperiod eller tillfällig licens räcker för utveckling; en full licens krävs för produktion. +- **Hur lägger jag till dokument?** Använd `index.add("YOUR_DOCUMENT_DIRECTORY")` för att massladda filer. +- **Hur hanteras specialtecken?** Konfigurera alfabetordlistan och escapera tecken som `()":&|!^~*?` innan sökningen körs. + +## Vad är “förbättra frågeprestanda”? +Att förbättra frågeprestanda innebär att minska den tid det tar för en sökförfrågan att färdas genom indexet, matcha termer och returnera resultat. Genom att konfigurera indexet korrekt och förbereda frågor som stämmer överens med den konfigurationen eliminerar du onödig bearbetning och uppnår snabbare svarstider. + +## Varför använda GroupDocs.Search Java för högpresterande sökningar? +- **Scalable indexing** – Hanterar miljontals dokument med inkrementella uppdateringar. +- **Rich language support** – Inbyggda analysverktyg för många alfabet och specialtecken. +- **Easy integration** – Fungerar med alla Java‑baserade applikationer, från Spring Boot‑tjänster till skrivbordsverktyg. + +## Förutsättningar + +Innan vi dyker ner, se till att du har följande redo: + +### Nödvändiga bibliotek och beroenden +To use GroupDocs.Search in a Maven project, include the following configurations: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Miljöinställning +- JDK 8 eller nyare installerad och konfigurerad. +- IDE såsom IntelliJ IDEA eller Eclipse. + +### Kunskapsförutsättningar +- Grundläggande Java‑programmering. +- Bekantskap med Maven. +- Förståelse för dokumenthanteringskoncept. + +## Konfigurera GroupDocs.Search för Java + +### 1. Installera via Maven eller direkt nedladdning +Lägg till XML‑snutten ovan i din `pom.xml`. Om du föredrar ett manuellt tillvägagångssätt, ladda ner biblioteket från den officiella webbplatsen: + +[GroupDocs.Search för Java‑utgåvor](https://releases.groupdocs.com/search/java/) + +### 2. Skaffa en licens +Du kan erhålla en gratis provperiod eller en tillfällig licens här: + +[GroupDocs licenssida](https://purchase.groupdocs.com/temporary-license) + +### 3. Grundläggande initiering +Create an `Index` object that points to a folder where the index files will be stored: + +```java +import com.groupdocs.search.*; + +public class SearchInitialization { + public static void main(String[] args) { + Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); + System.out.println("GroupDocs.Search initialized successfully."); + } +} +``` + +## Implementeringsguide + +### Skapa och konfigurera ett index +Genom att konfigurera alfabetordlistan kan du bestämma hur specialtecken behandlas, vilket är avgörande för **förbättra frågeprestanda**. + +#### Steg 1: Initiera index +```java +Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); +``` + +#### Steg 2: Konfigurera teckentyper +```java +index.getDictionaries().getAlphabet() + .setRange(new char[] {'&'}, CharacterType.Letter) + .setRange(new char[] {'-'}, CharacterType.Separator); +``` +Att behandla `&` som en bokstav och `-` som en separator säkerställer att sökmotorn tolkar frågor på det sätt du förväntar dig. + +### Indexera dokument +Nu ska vi **lägga till dokument i index** så att de blir sökbara. + +#### Steg 3: Lägg till dokument +```java +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` +Metoden skannar den angivna mappen rekursivt och indexerar varje stödd filtyp. + +### Förbered sökfrågan +För att **escapa specialtecken i fråga**, normaliserar vi först inmatningen baserat på alfabetkonfigurationen, och lägger sedan till escape‑sekvenser. + +#### Steg 4: Modifiera specialtecken +```java +StringBuilder result = new StringBuilder(); +String word = "rock&roll-music"; + +for (int i = 0; i < word.length(); i++) { + char character = word.charAt(i); + CharacterType characterType = index.getDictionaries().getAlphabet().getCharacterType(character); + + if (characterType == CharacterType.Separator) { + result.append(' '); + } else { + result.append(character); + } +} +``` + +#### Steg 5: Escapa specialtecken +```java +String specialCharacters = "()\":&|!^~*?"; +for (int i = result.length() - 1; i >= 0; i--) { + char c = result.charAt(i); + if (specialCharacters.indexOf(c) != -1) { + result.insert(i, '\\'); + } +} +String query = result.toString(); +if (query.contains(" ")) { + query = "\"" + query + "\""; +} +``` +Escaping förhindrar att parsern missförstår symboler som operatorer. + +### Utföra sökningen +Slutligen kör frågan mot det förberedda indexet. + +#### Steg 6: Utför sökning +```java +import com.groupdocs.search.results.*; + +SearchResult searchResult = index.search(query); +``` +`search`‑metoden returnerar ett `SearchResult`‑objekt som innehåller matchade dokument, utdrag och relevanspoäng. + +## Praktiska tillämpningar + +### Fallstudie 1: Dokumenthanteringssystem +Advokatbyråer kan snabbt hitta ärendehandlingar genom att indexera PDF‑filer, Word‑dokument och e‑post. Genom att **förbättra frågeprestanda** spenderar jurister mindre tid på att vänta på resultat och mer tid på att granska innehållet. + +### Fallstudie 2: E‑handelsplattformar +Online‑återförsäljare indexerar produktbeskrivningar, specifikationer och recensioner. Korrekt escaperade frågor låter kunder söka efter fraser som `4‑K TV` utan fel, medan snabb frågeexekvering håller shoppingupplevelsen smidig. + +## Prestandaöverväganden & tips +- **Uppdatera indexet** efter massimporter eller stora uppdateringar för att hålla söklatensen låg. +- **Tilldela tillräckligt heap‑minne** (`-Xmx2g` eller högre) för stora datamängder. +- **Återanvänd `Index`‑instansen** över flera sökningar istället för att skapa om den varje gång. +- **Profilera frågeexekvering** med Javas inbyggda verktyg för att identifiera flaskhalsar. + +## Vanliga fallgropar & lösningar + +| Problem | Varför det händer | Lösning | +|-------|-------------------|--------| +| Frågor returnerar inga resultat efter att nya filer har lagts till | Indexet har inte uppdaterats | Anropa `index.add(newPath)` eller bygg om indexet. | +| Fel om oväntade tecken | Specialtecken har inte escaperats | Säkerställ att escape‑logiken från Steg 5 körs innan sökningen. | +| Högt minnesbruk | Stora resultatuppsättningar laddas på en gång | Iterera över `. + +**Q: Kan GroupDocs.Search integreras med Spring Boot?** +A: Ja. Definiera `Index`aperas i en fråga?** +A: Tecknen `()\":&|!^~*?` kräver ett inledande bakstreck (`\`) för att: Hur kan jag uppdatera ett befintligt index med nyuppladdade dokument?** +A: Anropa `index.add("NEW_DOCUMENT_DIRECTORY")`; biblioteket kommer att slå samman nya poster utan att bygga om hela indexet. + +**Q: Är GroupDocs.Search lämplig för real‑tidsökning?** +A: Absolut. Biblioteket stödjer snabba inkrementella uppdateringar och låglatensfrågor, vilket gör det idealiskt för live‑sökfält. + +## Resurser +- [Dokumentation](https://docs.groupdocs.com/search/java/) +- [API‑referens](https://reference.groupdocs.com/) + +--- + +**Senast uppdaterad:** 2026-01-21 +**Testat med:** GroupDocs.Search Java 25.4 +**Författare:** GroupDocs \ No newline at end of file diff --git a/content/swedish/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md b/content/swedish/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md new file mode 100644 index 00000000..5e0b8377 --- /dev/null +++ b/content/swedish/java/search-network/java-groupdocs-search-configuration-sync-guide/_index.md @@ -0,0 +1,223 @@ +--- +date: '2026-01-21' +description: Lär dig hur du lägger till GroupDocs Maven‑beroendet, konfigurerar och + synkroniserar ett Java‑söknätverk samt lägger till kataloger för indexering med + GroupDocs.Search. +keywords: +- Java Search Network Configuration +- GroupDocs.Search for Java +- Document Indexing and Retrieval +title: GroupDocs Maven-beroende – Java-sökning nätverkssynkronisering +type: docs +url: /sv/java/search-network/java-groupdocs-search-configuration-sync-guide/ +weight: 1 +--- + + och synkDocs Maven‑beroendet** i ditt projekt och sedan konfigurerar ett robust Java‑söknätverk med hjälp av GroupDocs.Search. Oavsett om du hanterar jurid akademiska papper, kommer stegen nedan att hjälpa dig att indexera, söka och hålla dina shards synkroniserade effektivt. + +## Introduktion + +Att hantera och söka i massiva dokumentsamlingar är en daglig utmaning för många organisationer. Genom att integrera **GroupDocs Maven‑beroendet** får du tillgång till en kraftfull indexeringsmotor som kan skalas över flera noder. Denna handledning guidar dig genom att sätta upp beroendet, distribuera nätverksnoder, lägga till katalog för optimal prestanda. + +### Snabba svar +- **Vad är GroupDocs Maven‑beroendet?** Ett Maven‑artefakt som tar med GroupDocs.Search‑biblioteket i ditt Java‑projekt. +- **Varför använda ett söknätverk?** Det fördelar indexerings‑ en för produkt alla klasser du behöver för att bygga sökbara index, hantera nätverksnoder och utföra snabba frågor. Att lägga till det i din `pom.xml` säkerställer att Maven hämtar rätt binärer och transitiva beroenden. + +## Hur man lägger till GroupDocs Maven‑beroendet + +### Maven‑konfiguration + +Lägg till repository och beroende i din `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +> **Pro tip:** Håll versionsnumret uppdaterat genom att kontrollera den officiella releases‑sidan. + +Du kan också ladda ner JAR‑filen direkt från den officiella webbplatsen: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +## Förutsättningar + +- **JDK** (11 eller nyare) installerad. +- En IDE såsom IntelliJ IDEA eller Eclipse. +- Grundläggande kunskaper i Java, Maven‑färdighet och förståelse för nätverksnodkoncept. +- En giltig GroupDocs.Search‑licens (gratis prov eller kommersiell). + +## Grundläggande initiering och installation + +Börja med att skapa en indexkatalog: + +```java +import com.groupdocs.search.SearchIndex; +import com.groupdocs.search.options.IndexingOptions; + +// Create an index in the specified directory +SearchIndex index = new SearchIndex("YOUR_INDEX_DIRECTORY"); +``` + +Detta enkla steg förbereder miljön för den efterföljande nätverkskonfigurationen. + +## Implementeringsguide + +### Funktion 1: Konfiguration av söknätverk + +#### Översikt + +Konfiguration av söknätverket anger filvägar och portar som noderna ska använda för kommunikation. + +##### Ställ in vägar och portar +```java +import com.groupdocs.search.options.*; +import com.groupdocs.search.scaling.configuring.ConfiguringSearchNetwork; + +// Set custom paths for input/output directories +String basePath = "YOUR_DOCUMENT_DIRECTORY/AdvancedUsage/Scaling/SynchronizingShards/"; +int basePort = 49144; // Adjust if there's a port conflict + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` +`configuration`‑objektet innehåller nu alla nödvändiga inställningar för ditt söknätverk. + +### Funktion 2: Distribuera söknätverksnoder + +#### Översikt + +Distribuera noder för att sprida arbetsbelastningen över ditt nätverk. Master‑noden hanterar operationer och händelser. + +##### Distributionskod +```java +import com.groupdocs.search.scaling.*; +import com.groupdocs.search.options.Configuration; + +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +// Retrieve the master node for further operations +SearchNetworkNode masterNode = nodes[0]; +``` + +### Funktion 3: Prenumerera på söknätverksnod‑händelser + +#### Översikt + +Att lyssna på händelser möjliggör dynamisk hantering av förändringar eller uppdateringar i ditt nätverk. + +##### Prenumerationsimplementation +```java +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.scaling.SearchNetworkNodeEvents; + +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Funktion 4: Lägga till kataloger för indexering + +#### Översikt + +Att lägga till kataloger är kärnsteg som gör dina dokument sökbara. + +##### Dokumenttillägg +```java +import com.groupdocs.search.indexing.IndexingDocuments; +import com.groupdocs.search.scaling.SearchNetworkNode; + +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +``` + +### Funktion 5: Synkronisera shards i söknätverksnod + +#### Översikt + +Synkronisering säkerställer datakonsistens över alla shards. + +##### Synkroniseringskod +```java +import com.groupdocs.search.indexing.Indexer; +import com.groupdocs.search.scaling.SearchNetworkNode; +import com.groupdocs.search.options.SynchronizeOptions; + +SearchNetworkNode node = null; // Assume 'node' is initialized as a SearchNetworkNode + +def synchronizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + SynchronizeOptions options = new SynchronizeOptions(); + indexer.synchronize(options); +} +``` + +### Funktion 6: Stänga söknätverksnoder + +#### Översikt + +Att korrekt stänga noder frigör resurser och förhindrar minnesläckor. + +##### Nodstängning +```java +import com.groupdocs.search.scaling.SearchNetworkNode; + +for (SearchNetworkNode node : nodes) { + node.close(); +} +``` + +## Praktiska tillämpningar + +1. **Juridisk dokumenthantering** – Hämta snabbt ärenden och prejudikat. +2. **Finansiell bokföring** – Få åtkomst till uttalanden och revisionsspår på sekunder. +3. **Akademisk forskning** – Sök bland tusentals artiklar för att hitta relevanta citat. + +## Prestandaöverväganden + +- **Optimera frågor** – Skriv koncisa frågor för att minska svarstiden. +- **Minneshantering** – Övervaka JVM‑heap‑användning; överväg GC‑optimering för stora index. +- **Skalningsstrategi** – Lägg till noder proportionellt mot datavolym och frågelast. + +## Vanliga problem och lösningar + +| Problem | Orsak | Lösning | +|-------|-------|----------| +| Noder kan inte ansluta | Portkonflikt | Ändra `basePort` till ett ledigt värde | +| Index uppdateras inte | Händelseprenumeration saknas | Säkerställ att `SearchNetworkNodeEvents.subscribe(masterNode)` anropas | +| Hög latens | Otillräckligt antal shards | Öka antalet noder och balansera dokumentfördelning | + +## Vanliga frågor + +**Q: Vad är den främsta fördelen med att använda GroupDocs.Search?** +A: Det erbjuder snabba, skalbara sökfunktioner över stora dokumentuppsättningar med minimal konfiguration. + +**Q: Kan jag anpassa nodkonfigurationer i ett söknätverk?** +A: Ja, du kan ange egna vägar, portar och andra alternativ via `Configuration`‑objektet. + +**Q: Hur lägger jag till kataloger för indexering efter att nätverket körs?** +A: Anropa `IndexingDocuments.addDirectories(masterNode, "path")` när du behöver indexera nya mappar. + +**Q: Hur synkroniserar jag shards när en ny nod ansluter till nätverket?** +A: Använd `synchronizeShards`‑metoden som visas ovan på den nyinlagda noden. + +**Q: Behöver jag en licens för utveckling?** +A: En gratis provlicens räcker för testning; en kommersiell licens krävs för produktion. + +## Slutsats + +Genom att följa den här guiden vet du nu hur du **lägger till GroupDocs Maven‑beroendet**, konfigurerar ett flernodigt söknätverk, indexerar kataloger och håller shards synkroniserade. Dessa steg lägger grunden för en högpresterande dokumentsökningslösning som kan växa i takt med din organisations behov. + +--- + +**Senast uppdaterad:** 2026-01-21 +**Testad med:** GroupDocs.Search 25.4 +**Författare:** GroupDocs + +--- \ No newline at end of file diff --git a/content/swedish/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/swedish/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..3be54f94 --- /dev/null +++ b/content/swedish/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,202 @@ +--- +date: '2026-01-21' +description: Lär dig hur du optimerar shards med GroupDocs.Search för Java och hur + du konfigurerar söknätverket, utför textsökning och hanterar portkonflikter. +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'Hur man optimerar shards i GroupDocs.Search för Java: En omfattande guide' +type: docs +url: /sv/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# Hur man optimerar shards i GroupDocs.Search för Java: En omfattande guide + +Effektiv dokumentsökning är avgörande för utvecklare och företag som hanterar stora databaser eller vill effektivisera interna dokumentåtervinningsprocesser. Om du undrar **hur man optimerar shards**, kommer den här guiden att gå igenom stegen för att förbättra prestanda, konfigurera ditt söknätverk och hantera vanliga utmaningar som portkonflikter. **GroupDocs.Search Java** erbjuder sömlös konfiguration och optimering av ditt söknätverk, vilket förbättrar både prestanda och användarupplevelse. + +## Snabba svar +- **Vad är shard‑optimerör man textsökning?** Använd ` din söksträng. +Documents.addDirectories`. +- **Hur hanterar man portkonflikter?** Ändra variabeln `basePort` till en ledig port på din maskin. + +## Hur man konfigurerar söknätverk +Innan du dyker in i indexering och sökning behöver du ensnitt förklarar stegen för att sätta upp nätverket, välja en port och undvika vanliga port‑konfliktproblem. + +## Hur man indexerar dokument i Java +När nätverket är igång är nästa steg att fylla det med innehåll. Vi visar hur du lägger till flera dokumentmappar så att motorn kan bygga ett sökbart index. + +## Hur man utför textsökning +Efter indexering vill du snabbt hämta information. Detta avsnitt demonstrerar det enklaste sättet att köra en textsökning över alla noder. + +## Hur man hanterar portkonflikter +Om standardporten (`49132`) redan är i bruk, ändra helt enkelt `basePort`‑värdet till en ledig port och starta om konfigurationen. Detta förhindrar startfel och håller ditt nätverk stabilt. + +## Förutsättningar +Innan vi börjar, se till att du har följande förutsättningar på plats: + +### Nödvändiga bibliotek, versioner och beroenden +För att implementera denna lösning, inkludera GroupDocs.Search‑biblioteket via Maven genom att lägga till följande konfiguration i din `pom.xml`‑fil: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` +Alternativt, ladda ner den senaste versionen från [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Krav för miljöinställning +- Se till att din utvecklingsmiljö stödjer Java (JDK 8 eller senare). +- Tillgång till en nätverkskonfiguration som tillåter portanvändning. + +### Kunskapsförutsättningar +En grundläggande förståelse för Java‑programmering, inklusive objekt‑orienterade principer och undantagshantering, kommer att vara fördelaktigt för denna handledning. + +## Installera GroupDocs.Search för Java +För att börja använda GroupDocs.Search i ditt projekt, följ dessa steg: + +1. **Lägg till beroendet**: Som visat ovan, lägg till det nödvändiga Maven‑beroendet i ditt projekt eller ladda ner direkt från releases‑sidan. +2. **License Acquisition**: + - För en gratis provperiod, använd biblioteket utan begränsningar på funktioner men med vissa användningsbegränsningar. + - Skaffa en tillfällig licens för full åtkomst till funktioner under utvärdering genom att besöka [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/). + - Köp en full licens om du bestämmer dig för att integrera GroupDocs.Search i din produktionsmiljö. +3. **Grundläggande initiering och konfiguration**: Initiera konfigurationen med `Configuration`‑klassen, ange basvägen för dokument och specificera ett portnummer: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## Implementeringsguide +Låt oss nu utforska implementeringen av nyckelfunktioner med GroupDocs.Search Java. + +### Funktion: Konfigurera söknätverk +**Översikt**: Att sätta upp ett söknätverk innebär att definiera din dokumentkatalog och konfigurera den med en specifik port för kommunikation mellan noder. + +#### Steg 1: Definiera dokumentkataloger och port +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### Steg 2: Konfigurera söknätverk +Skapa konfigurationsobjektet med de definierade sökvägarna: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### Funktion: Distribuera söknätverksnoder +**Översikt**: Distribuera noder för att hantera dokumentsökningar effektivt över ditt nätverk. + +#### Steg 1: Distribuera noder med konfiguration +Distribuera söknätverksnoder och identifiera master‑noden för centraliserad hantering: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### Funktion: Prenumerera på nätverksnod‑händelser +**Översikt**: Övervaka ditt söknätverk genom att prenumerera på händelser som meddelar dig om viktiga förändringar eller åtgärder. + +#### Steg 1: Prenumerera på master‑nod‑händelser +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### Funktion: Indexera dokument i nätverksnoder +**Översikt**: Lägg till kataloger som innehåller dokument i indexeringsprocessen för effektiva sökningar. + +#### Steg 1: Lägg till dokumentkataloger i indexeringsprocessen +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### Funktion: Textsökning i nätverksnoder +**Översikt**: Utför textsökningar över alla indexerade dokument inom ditt söknätverk. + +#### Steg 1: Utför en textsökning +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### Funktion: Optimera shards +**Översikt**: Förbättra prestanda genom att optimera shards inom indexeraren i din söknätverksnod. + +#### Steg 1: Optimera indexer‑shards +Optimera shards för att förbättra sökeffektiviteten (detta är där **hur man optimerar shards** verkligen spelar roll): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## Praktiska tillämpningar +GroupDocs.Search för Java kan tillämpas i olika verkliga scenarier: +1. **Företagsdokumenthantering**: Underlätta dokumentåtervinning över stora företagsdatabaser. +2. **E‑handelsplattformar**: Förbättra produktsökfunktioner med hjälp av optimerad indexering och frågefunktioner. +3. **Juristbyråer**: Hantera och återvinn ärenden och dokument från omfattande arkiv på ett effektivt sätt. +4. **Bibliotekssystem**: Effektivisera katalogiseringsprocessen genom att integrera med digitala bibliotekssystem för snabba sökningar. +5. **Content Management Systems (CMS)**: Förbättra innehållsupptäckten genom avancerade sökfunktioner. + +## Prestandaöverväganden +För att säkerställa optimal prestanda för din GroupDocs.Search‑implementation: +- Optimera regelbundet shards för att minska svarstider för frågor. +- Övervaka och hantera minnesanvändning, särskilt i miljöer som hanterar stora datamängder. +- Följ Java‑bästa praxis för skräpsamling och resurshantering för att upprätthålla systemeffektivitet. + +## Slutsats +Genom att följa denna omfattande guide har du lärt dig hur man sätter upp och optimerar ett söknätverk med GroupDocs.Search för Java. Med dessa kunskaper är du nu rustad att hantera effektiva dokumentsökningar över olika applikationer, vilket förbättrar ditt projekts prestanda och användarupplevelse. För att ytterligare utforska möjligheterna med GroupDocs.Search, överväg att integrera det med andra system eller utforska ytterligare funktioner som finns i deras dokumentation. + +## FAQ‑avsnitt +1. **Vad är shard‑optimering?** + - Shard‑optimering förbättrar söknätverkets prestanda genom att organisera2. **Hur hanterar jag portkonflikter när jag konfigurerar ett söknätverk?** + -. +3. **Kan GroupDocs.Search integreras med befintliga Java‑applikationer?** + - Ja, det kan integreras sömlöst genom att inkludera. **Vilka vanliga problem kan uppstå under installationen?** + - Vanliga problem inkluderar felaktiga portkonfigurationer och saknade beroenden; se till att du följer förutsättningarna noggrant. + +## Vanliga frågor + +**Q: Hur påverkar shard‑optimering frågehastigheten?** +A: Optimering av shards komprimerar indexet, minskar disk‑I/O och ger vanligtvis snabbare svar på frågor. + +**Q: Är det säkert att köra `optimizeShards` på en aktiv nod?** +A: Ja, operationen är designad för att köras utan driftstopp, men det är bäst att schemalägga den under perioder med låg trafik för stora index. + +**Q: Kan jag anpassa `OptimizeOptions`?** +A: Absolut. Du kan sätta parametrar som `maxSegmentSize` eller `mergeFactor` för att finjustera optimeringsprocessen. + +**Q: Vad ska jag göra om jag får ett `IOException` under optimeringen?** +A: Verifiera filsystembehörigheter, säkerställ tillräckligt med diskutrymme och bekräfta att ingen annan process låser indexf, optimeraren slår ihop segment och tar bort tombstones, vilket frigör utrymme som upptas av raderade dokument. + +--- + +**Senast uppdaterad:** 2026-01-21 +**Testad med:** GroupDocs.Search 25.4 för Java +**Författare:** GroupDocs \ No newline at end of file diff --git a/content/thai/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md b/content/thai/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md new file mode 100644 index 00000000..ce7bc07b --- /dev/null +++ b/content/thai/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/_index.md @@ -0,0 +1,216 @@ +--- +date: '2026-01-21' +description: เรียนรู้วิธีปรับปรุงประสิทธิภาพการค้นหาและเพิ่มเอกสารเข้าสู่ดัชนีพร้อมกับการหลีกเลี่ยงอักขระพิเศษอย่างถูกต้องโดยใช้ + GroupDocs.Search Java. +keywords: +- GroupDocs.Search Java +- document index optimization +- search query performance +title: 'ปรับปรุงประสิทธิภาพการค้นหาด้วย GroupDocs.Search Java: ปรับแต่งดัชนีและการค้นหา' +type: docs +url: /th/java/performance-optimization/master-groupdocs-search-java-index-query-optimization/ +weight: 1 +--- + +# ปรับปรุงประสิทธิภาพการค้นหาด้วย GroupDocs.Search Java: ปรับแต่งดัชนีและการค้นหา + +การจัดการคอลเลกชันเอกสารขนาดมหาศาลอย่างมีประสิทธิภาพเริ่มต้นด้วย **การปรับปรุงประสิทธิภาพการค้นหา** ในบทเรียนนี้คุณจะได้เรียนรู้วิธีสร้างและกำหนดค่าดัชนีประสิทธิภาพสูง, **เพิ่มเอกสารลงในดัชนี**, และ **หลีกเลี่ยงอักขระพิเศษในคำค้น** อย่างถูกต้องเพื่อให้การค้นหาเร็วขึ้นและให้ผลลัพธ์ที่แม่นยำ ไม่ว่าคุณจะสร้างฐานความรู้ขององค์กรหรือแคตาล็อกอีคอมเมิร์ซที่ค้นหาได้ การเชี่ยวชาญขั้นตอนเหล่านี้จะทำให้แอปพลิเคชันของคุณตอบสนองได้แม้ภายใต้โหลดสูง + +## คำตอบสั้น +- **เป้าหมายหลักคืออะไร?** ปรับปรุงประสิทธิภาพการค้นหาโดยการปรับแต่งดัชนีและการจัดการคำค้น +- **ใช้ไลบรารีอะไร?** GroupDocs.Search สำหรับ Java +- **ต้องการไลเซนส์หรือไม่?** ไลเซนส์ทดลองหรือไลเซนส์ชั่วคราวเพียงพอสำหรับการพัฒนา; ต้องมีไลเซนส์เต็มสำหรับการใช้งานจริง +- **เพิ่มเอกสารอย่างไร?** ใช้ `index.add("YOUR_DOCUMENT_DIRECTORY")` เพื่อโหลดไฟล์เป็นชุด +- **จัดการอักขระพิเศษอย่างไร?** กำหนดพจนานุกรมอักษรและหลีกเลี่ยงอักขระเช่น `()":&|!^~*?` ก่อนทำการค้นหา + +## “ปรับปรุงประสิทธิภาพการค้นหา” คืออะไร? +การปรับปรุงประสิทธิภาพการค้นหาหมายถึงการลดเวลาที่คำขอค้นใช้ในการเดินทางผ่านดัชนี, ตรงกับคำ, และส่งคืนผลลัพธ์ โดยการกำหนดค่าดัชนีอย่างถูกต้องและเตรียมคำค้นให้สอดคล้องกับการกำหนดค่านั้น คุณจะขจัดการประมวลผลที่ไม่จำเป็นและได้เวลาตอบสนองที่เร็วขึ้น + +## ทำไมต้องใช้ GroupDocs.Search Java สำหรับการค้นหาประสิทธิภาพสูง? +- **การทำดัชนีที่ขยายได้** – รองรับการจัดการเอกสารหลายล้านรายการพร้อมการอัปเดตแบบเพิ่มส่วน +- **รองรับหลายภาษา** – มีตัววิเคราะห์ในตัวสำหรับอักษรหลายชุดและอักขระพิเศษหลายประเภท +- **การบูรณาการที่ง่าย** – ทำงานร่วมกับแอปพลิเคชัน Java ใด ๆ ไม่ว่าจะเป็นบริการ Spring Boot หรือเครื่องมือเดสก์ท็อป + +## ข้อกำหนดเบื้องต้น + +ก่อนที่เราจะเริ่ม, โปรดตรวจสอบว่าคุณมีสิ่งต่อไปนี้พร้อมใช้งาน: + +### ไลบรารีและการพึ่งพาที่จำเป็น +เพื่อใช้ GroupDocs.Search ในโครงการ Maven ให้เพิ่มการกำหนดค่าดังต่อไปนี้: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### การตั้งค่าสภาพแวดล้อม +- ติดตั้ง JDK 8 หรือใหม่กว่าและกำหนดค่าให้เรียบร้อย +- IDE เช่น IntelliJ IDEA หรือ Eclipse + +### ความรู้พื้นฐานที่ต้องมี +- การเขียนโปรแกรม Java เบื้องต้น +- ความคุ้นเคยกับ Maven +- ความเข้าใจพื้นฐานเกี่ยวกับการจัดการเอกสาร + +## การตั้งค่า GroupDocs.Search สำหรับ Java + +### 1. ติดตั้งผ่าน Maven หรือดาวน์โหลดโดยตรง +เพิ่มส่วน XML ข้างต้นลงในไฟล์ `pom.xml` ของคุณ หากคุณต้องการวิธีการแบบแมนนวล ให้ดาวน์โหลดไลบรารีจากเว็บไซต์อย่างเป็นทางการ: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### 2. รับไลเซนส์ +คุณสามารถรับไลเซนส์ทดลองหรือไลเซนส์ชั่วคราวได้ที่นี่: + +[GroupDocs Licensing Page](https://purchase.groupdocs.com/temporary-license) + +### 3. การเริ่มต้นพื้นฐาน +สร้างอ็อบเจ็กต์ `Index` ที่ชี้ไปยังโฟลเดอร์ที่ไฟล์ดัชนีจะถูกจัดเก็บ: + +```java +import com.groupdocs.search.*; + +public class SearchInitialization { + public static void main(String[] args) { + Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); + System.out.println("GroupDocs.Search initialized successfully."); + } +} +``` + +## คู่มือการนำไปใช้ + +### การสร้างและกำหนดค่าดัชนี +การกำหนดพจนานุกรมอักษรทำให้คุณสามารถตัดสินใจว่าจะแบ่งการจัดการอักขระพิเศษอย่างไร ซึ่งเป็นสิ่งสำคัญสำหรับ **การปรับปรุงประสิทธิภาพการค้นหา** + +#### ขั้นตอนที่ 1: เริ่มต้น Index +```java +Index index = new Index("YOUR_DOCUMENT_DIRECTORY/output/AdvancedUsage"); +``` + +#### ขั้นตอนที่ 2: กำหนดประเภทอักขระ +```java +index.getDictionaries().getAlphabet() + .setRange(new char[] {'&'}, CharacterType.Letter) + .setRange(new char[] {'-'}, CharacterType.Separator); +``` +การถือว่า `&` เป็นตัวอักษรและ `-` เป็นตัวคั่นทำให้เครื่องมือค้นหาแยกคำค้นตามที่คุณคาดหวัง + +### การทำดัชนีเอกสาร +ต่อไปเราจะ **เพิ่มเอกสารลงในดัชนี** เพื่อให้สามารถค้นหาได้ + +#### ขั้นตอนที่ 3: เพิ่มเอกสาร +```java +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` +เมธอดนี้จะสแกนโฟลเดอร์ที่ระบุแบบเรียกซ้ำและทำดัชนีทุกประเภทไฟล์ที่รองรับ + +### การเตรียมคำค้นหา +เพื่อ **หลีกเลี่ยงอักขระพิเศษในคำค้น**, เราจะทำการปรับรูปแบบอินพุตตามการกำหนดค่าพจนานุกรมอักษรก่อน, แล้วเพิ่มลำดับการหลีกเลี่ยง + +#### ขั้นตอนที่ 4: ปรับเปลี่ยนอักขระพิเศษ +```java +StringBuilder result = new StringBuilder(); +String word = "rock&roll-music"; + +for (int i = 0; i < word.length(); i++) { + char character = word.charAt(i); + CharacterType characterType = index.getDictionaries().getAlphabet().getCharacterType(character); + + if (characterType == CharacterType.Separator) { + result.append(' '); + } else { + result.append(character); + } +} +``` + +#### ขั้นตอนที่ 5: หลีกเลี่ยงอักขระพิเศษ +```java +String specialCharacters = "()\":&|!^~*?"; +for (int i = result.length() - 1; i >= 0; i--) { + char c = result.charAt(i); + if (specialCharacters.indexOf(c) != -1) { + result.insert(i, '\\'); + } +} +String query = result.toString(); +if (query.contains(" ")) { + query = "\"" + query + "\""; +} +``` +การหลีกเลี่ยงทำให้ตัวแยกวิเคราะห์ไม่ตีความสัญลักษณ์เป็นตัวดำเนินการโดยผิดพลาด + +### การดำเนินการค้นหา +สุดท้ายให้เรียกคำค้นต่อดัชนีที่เตรียมไว้ + +#### ขั้นตอนที่ 6: ดำเนินการค้นหา +```java +import com.groupdocs.search.results.*; + +SearchResult searchResult = index.search(query); +``` +เมธอด `search` จะคืนค่าอ็อบเจ็กต์ `SearchResult` ที่บรรจุเอกสารที่ตรงกัน, snippet, และคะแนนความเกี่ยวข้อง + +## การประยุกต์ใช้จริง + +### กรณีศึกษา 1: ระบบจัดการเอกสาร +บริษัทกฎหมายสามารถค้นหาไฟล์คดีได้อย่างรวดเร็วโดยทำดัชนี PDF, Word, และอีเมล โดย **การปรับปรุงประสิทธิภาพการค้นหา** ทำให้ทนายใช้เวลาน้อยลงในการรอผลลัพธ์และใช้เวลามากขึ้นในการตรวจสอบเนื้อหา + +### กรณีศึกษา 2: แพลตฟอร์มอี‑คอมเมิร์ซ +ผู้ค้าปลีกออนไลน์ทำดัชนีคำอธิบายสินค้า, สเปค, และรีวิว การหลีกเลี่ยงคำค้นอย่างถูกต้องทำให้ลูกค้าสามารถค้นหาวลีเช่น `4‑K TV` ได้โดยไม่มีข้อผิดพลาด ในขณะที่การดำเนินการค้นหาเร็วทำให้ประสบการณ์การช็อปปิ้งราบรื่น + +## ข้อควรพิจารณาเรื่องประสิทธิภาพและเคล็ดลับ + +- **รีเฟรชดัชนี** หลังจากการนำเข้าจำนวนมากหรืออัปเดตใหญ่ เพื่อให้เวลาการค้นือต่ำลง +- **จัดสรรหน่วยความจำ heap เพียงพอ** (`-Xmx2g` หรือมากกว่า) สำหรับชุดข้อมูลขนาดใหญ่ +- **ใช้ instance ของ `Index` ซ้ำ** ในหลายการค้นหา แทนการสร้างใหม่ทุกครั้ง +- **โปรไฟล์การดำเนินการคำค้น** ด้วยเครื่องมือในตัวของ Java เพื่อหาจุดคอขวด + +## ข้อผิดพลาดทั่วไปและวิธีแก้ + +| ปัญหา | สาเหตุ | วิธีแก้ | +|-------|--------|--------| +| คำค้นไม่ให้ผลลัพธ์หลังจากเพิ่มไฟล์ใหม่ | ดัชนีไม่ได้อัปเดต | เรียก `index.add(newPath)` หรือสร้างดัชนีใหม่ | +| เกิดข้อผิดพลาดเกี่ยวกับอักขระที่ไม่คาดคิด | อักขระพิเศษไม่ได้หลีกเลี่ยง | ตรวจสอบให้แน่ใจว่าตรรกะการหลีกเลี่ยงจากขั้นตอน 5 ทำงานก่อนการ อย่าง lazy หรือจำกัดผลลัพธ์ด้วย `index.search(query, 100)` | + +## คำถามที่พบบ่อย + +**ถาม: จะจัดการกับชุดข้อมูลขนาดใหญ่มากด้วย GroupDocs.Search อย่างไร?** +ตอบ: ใช้การทำดัชนีแบบเพิ่มส่วน (`index.add`) และกำหนดเวลาการปรับแต่งดัชนีเป็นระ SSD เพื่อให้ I/O เร็วขึ้น + +**ถาม: สามารถบูรณาการ GroupDocs.Search กับ Spring Boot ได้หรือไม่?** +ตอบ: ได้. กำหนด bean `Index` ในคลาส `@Configuration` แล้วฉีดเข้าไปที่ส่วนที่ต้องการใช้การค้นหา + +**ถาม: อัก~*?` ต้องมีเครื่องหมาย backslash (`\ขระธรรมดา + +**ถาม: จะอัปเดตดัชนีที่มีอยู่ด้วยเอกสารที่อัปโหลดใหม่อย่างไร?** +ตอบ: เรียก `index.add("NEW_DOCUMENT_DIRECTORY")`; ไลบรารีจะผสานรายการใหม่โดยไม่ต้องสร้างดัชนีใหม่ทั้งหมด + +**ถาม: GroupDocs.Search เหมาะกับสถานการณ์การค้นหาแบบเรียล‑ไทม์หรือไม่?** +ตอบ: แน่นอน. ไลบรารีรองรับการอัปเดตแบบเพิ่มส่วนที่เร็วและคำค้นที่มี latency ต่ำ ทำให้เหมาะกับกล่องค้นหาแบบสด + +## แหล่งข้อมูล +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/) + +--- + +**อัปเดตล่าสุด:** 2026-01-21 +**ทดสอบกับ:** GroupDocs.Search Java 25.4 +**ผู้เขียน:** GroupDocs + +--- \ No newline at end of file diff --git a/content/thai/java/search-network/optimize-search-network-groupdocs-java/_index.md b/content/thai/java/search-network/optimize-search-network-groupdocs-java/_index.md new file mode 100644 index 00000000..43f4c6a3 --- /dev/null +++ b/content/thai/java/search-network/optimize-search-network-groupdocs-java/_index.md @@ -0,0 +1,202 @@ +--- +date: '2026-01-21' +description: เรียนรู้วิธีเพิ่มประสิทธิภาพของชาร์ดโดยใช้ GroupDocs.Search สำหรับ Java + และวิธีกำหนดค่าเครือข่ายการค้นหา, ทำการค้นหาข้อความ, และจัดการข้อขัดแย้งของพอร์ต +keywords: +- GroupDocs.Search Java +- search network configuration +- document indexing +title: 'วิธีเพิ่มประสิทธิภาพ Shards ใน GroupDocs.Search สำหรับ Java: คู่มือฉบับสมบูรณ์' +type: docs +url: /th/java/search-network/optimize-search-network-groupdocs-java/ +weight: 1 +--- + +# วิธีการเพิ่มประอย่างมีประสิทธิภาพเป็นสิ่งสำคัญสำหรับนักพัฒนาและธุรกิจที่จัดการฐานข้อมูลขนาดใหญ่หรือกำลังมองหาวิธีทำให้กระบวนการเรียกคืนเอกสารภายในเป็นไปอย่างราบรื่น หากคุณกำลังสงสัย **how to optimize shards** คู่มือนี้จะพาคุณผ่านขั้นตอนต่าง ๆ เพื่อปรับปรุงประสิทธิภาพ ตั้งค่าเครือข่ายการค้นหา และจัดการกับความท้าทายทั่วไปเช่นปัญหาการชนกันของพอร์ต **GroupDocs.Search Java** ให้การกำหนดค่าและการเพิ่มประสิทธิภาพเครือข่ายการค้นหาอย่างต่อเนื่อง ส่งเสริมทั้งประสิทธิภาพและประสบการณ์ผู้ใช้ + +## คำตอบอย่างรวดเร็ว +- **Shard optimization คืออะไร?** เป็นการจัดระเบียบข้อมูลดัชนีเพื่อเร่งความเร็วของการสืบค้นและลดภาระการจัดเก็บ +- **จะตั้งค่าเครือข่ายการค้นหาอย่างไร?** กำหนดไดเรกทอรีฐานและพอร์ต แล้วปรับใช้โหนดโดยใช้ API ที่ให้มา +- **จะทำการค้นหาข้อความอย่างไร?** ใช้ `TextSearchInNetwork.searchAll` พร้อมสตริงคำสร้างดัชนีเอกสารใน Java อย่างไร?** เพิ่มไดเรกทอรีเอกสารไปยังโหนดหลักด้วย `IndexingDocuments.addDirectories` +- **จะจัดการกับการชนกันของพข่าย การเลือกพอร์ต และการหลีกเลต่อไปคือการป้อนเนื้อหาให้กับมัน เราจะแสดงวิธีการเพิ่มโฟลเดอร์เอกสารหลายโฟลเดอร์เพื่อให้เอนจินสามารถสร้างดัชนีที่สามารถค้นหาได้ + +## วิธีการทำการค้นหาข้อความ +หลังจากสร้างดัชนีแล้ว คุณจะต้องการดึงข้อมูลอย่างรวดเร็ว ส่วนนี้จะแสดงวิธีที่ง่ายที่สุดในการรันคำค้นข้อความทั่วทุกโหนด + +## วิธีการจัดการกับการชนกันของพอร์ต +หากพอร์ตเริ่มต้น (`49132`) ถูกใช้งานอยู่แล้ว เพียงเปลี่ยนค่าและรีสตาร์ทการตั้งค่า การร + +## ข้อกำหนดเบื้องต้น +ก่อนที่เราจะเริ่ม ให้ตรวจสอบว่าคุณมีข้อกำหนดต่อไปนี้พร้อมใช้งานแล้วหรือยัง: + +### ไลบรารีที่จำเป็น, เวอร์ชัน, และการพึ่งพา +เพื่อใช้งานโซลูชันนี้ ให้เพิ่มไลบรารี GroupDocs.Search ผ่าน Maven โดยเพิ่มการกำหนดค่าต่อไปนี้ในไฟล์ `pom.xml` ของคุณ: + +```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 (JDK 8 หรือใหม่กว่า) +- มีการเข้าถึงการกำหนดค่าเครือข่ายที่อนุญาตให้ใช้พอร์ตได้ + +### ความรู้เบื้องต้นที่จำเป็น +ความเข้าใจพื้นฐานเกี่ยวกับการเขียนโปรแกรม Java รวมถึงหลักการเชิงวัตถุและการจัดการข้อยกเว้น จะเป็นประโยชน์ต่อการทำตามบทเรียนนี้ + +## การตั้งค่า GroupDocs.Search สำหรับ Java +เพื่อเริ่มใช้ GroupDocs.Search ในโปรเจกต์ของคุณ ให้ทำตามขั้นตอนต่อไปนี้: + +1. **เพิ่ม Dependency**: ตามที่แสดงด้านบน ให้เพิ่ม Dependency ของ Maven ที่จำเป็นลงในโปรเจกต์ของคุณ หรือดาวน์โหลดโดยตรงจากหน้าปล่อยเวอร์ชัน +2. **การจัดหา License**: + - สำหรับการทดลองใช้ฟรี ให้ใช้ไลบรารีโดยไม่มีข้อจำกัดด้านฟีเจอร์ แต่มีข้อจำกัดการใช้งานบางประการ + - รับ License ชั่วคราวเพื่อเข้าถึงฟีเจอร์เต็มระหว่างการประเมินผลโดยเยี่ยมชม [GroupDocs Temporary License](https://purchase.groupdocs.com/temporary-license/) + - ซื้อ License เต็มรูปแบบหากคุณตัดสินใจนำ GroupDocs.Search ไปใช้ในสภาพแวดล้อมการผลิต + +3. **การเริ่มต้นและตั้งค่าเบื้องต้น**: + เริ่มต้นการกำหนดค่าด้วยคลาส `Configuration` โดยตั้งค่าเส้นทางฐานสำหรับเอกสารและระบุหมายเลขพอร์ต: + +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Adjust if necessary + +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +## คู่มือการนำไปใช้ +ต่อไปเราจะสำรวจการนำคุณลักษณะสำคัญต่าง ๆ ไปใช้ด้วย GroupDocs.Search Java + +### คุณลักษณะ: การกำหนดค่าเครือข่ายการค้นหา +**ภาพรวม**: การตั้งค่าเครือข่ายการค้นหาต้องกำหนดไดเรกทอรีเอกสารของคุณและกำหนดค่าพอร์ตเฉพาะสำหรับการสื่อสารระหว่างโหนด + +#### ขั้นตอนที่ 1: กำหนดไดเรกทอรีเอกสารและพอร์ต +```java +String basePath = "YOUR_DOCUMENT_DIRECTORY/OptimizingShards/"; +int basePort = 49132; // Change this if you encounter a network port issue +``` + +#### ขั้นตอนที่ 2: กำหนดค่าเครือข่ายการค้นหา +สร้างอ็อบเจกต์การกำหนดค่าด้วยเส้นทางที่กำหนดไว้: + +```java +Configuration configuration = ConfiguringSearchNetwork.configure(basePath, basePort); +``` + +### คุณลักษณะ: การปรับใช้โหนดเครือข่ายการค้นหา +**ภาพรวม**: ปรับใช้โหนดเพื่อจัดการการค้นหาเอกสารอย่างมีประสิทธิภาพทั่วเครือข่ายของคุณ + +#### ขั้นตอนที่ 1: ปรับใช้โหนดด้วยการกำหนดค่า +ปรับใช้โหนดเครือข่ายการค้นหาและระบุโหนดหลักสำหรับการจัดการศูนย์กลาง: + +```java +SearchNetworkNode[] nodes = SearchNetworkDeployment.deploy(basePath, basePort, configuration); +SearchNetworkNode masterNode = nodes[0]; +``` + +### คุณลักษณะ: การสมัครรับเหตุการณ์ของโหนดเครือข่าย +**ภาพรวม**: ตรวจสอบเครือข่ายการค้นหาของคุณโดยการสมัครรับเหตุการณ์ที่แจ้งให้คุณทราบถึงการเปลี่ยนแปลงหรือการกระทำสำคัญต่าง ๆ + +#### ขั้นตอนที่ 1: สมัครรับเหตุการณ์ของโหนดหลัก +```java +SearchNetworkNodeEvents.subscribe(masterNode); +``` + +### คุณลักษณะ: การสร้างดัชนีเอกสารในโหนดเครือข่าย +**ภาพรวม**: เพิ่มไดเรกทอรีที่มีเอกสารเข้าสู่กระบวนการสร้างดัชนีเพื่อการค้นหาที่มีประสิทธิภาพ + +#### ขั้นตอนที่ 1: เพิ่มไดเรกทอรีเอกสารเข้าสู่กระบวนการสร้างดัชนี +```java +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath"); +IndexingDocuments.addDirectories(masterNode, "YOUR_DOCUMENT_DIRECTORY/DocumentsPath2"); +``` + +### คุณลักษณะ: การค้นหาข้อความในโหนดเครือข่าย +**ภาพรวม**: ดำเนินการค้นหาข้อความทั่วเอกสารที่สร้างดัชนีทั้งหมดภายในเครือข่ายการค้นหาของคุณ + +#### ขั้นตอนที่ 1: ทำการค้นหาข้อความ +```java +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +### คุณลักษณะ: การเพิ่มประสิทธิภาพ Shards +**ภาพรวม**: ปรับปรุงประสิทธิภาพโดยการเพิ่มประสิทธิภาพ Shards ภายในตัวสร้างดัชนีของโหนดเครือข่ายการค้นหา + +#### ขั้นตอนที่ 1: เพิ่มประสิทธิภาพ Shards ของ Indexer +เพิ่มประสิทธิภาพ Shards เพื่อปรับปรุงประสิทธิภาพการค้นหา (นี่คือจุดที่ **how to optimize shards** มีความสำคัญจริง ๆ): + +```java +public static void optimizeShards(SearchNetworkNode node) { + Indexer indexer = node.getIndexer(); + OptimizeOptions options = new OptimizeOptions(); + indexer.optimize(options); +} + +optimizeShards(masterNode); + +// Perform a second text search to observe optimization effects +TextSearchInNetwork.searchAll(masterNode, "ligula", false); +``` + +## การประยุกต์ใช้ในเชิงปฏิบัติ +GroupDocs.Search สำหรับ Java สามารถนำไปใช้ในสถานการณ์จริงหลายรูปแบบ: +1. **การจัดการเอกสารระดับองค์กร**: อำนวยความสะดวกในการเรียกคืนเอกสารจากฐานข้อมูลขนาดใหญ่ขององค์กร +2. **แพลตฟอร์มอีคอมเมิร์ซ**: ปรับปรุงความสามารถในการค้นหาผลิตภัณฑ์ด้วยการสร้างดัชนีและการสืบค้นที่เพิ่มประสิทธิภาพ +3. **สำนักงานกฎหมาย**: จัดการและเรียกคืนไฟล์คดีและเอกสารจากคลังข้อมูลขนาดใหญ่ได้อย่างมีประสิทธิภาพ +4. **ระบบห้องสมุด**: ทำให้กระบวนการจัดทำรายการคาตาล็อกเป็นเรื่องง่ายโดยการบูรณาการกับระบบห้องสมุดดิจิทัลเพื่อการค้นหาอย่างรวดเร็ว +5. **ระบบจัดการเนื้อหา (CMS)**: ปรับปรุงการค้นพบเนื้อหาโดยใช้ความสามารถการค้นหาขั้นสูง + +## ปัจจัยที่ควรพิจารณาด้านประสิทธิภาพ +เพื่อให้การใช้งาน GroupDocs.Search ของคุณทำงานได้อย่างดีที่สุด: +- ทำการเพิ่มประสิทธิภาพ Shards อย่างสม่ำเสมอเพื่อลดเวลาตอบสนองของการสืบค้น +- ตรวจสอบและจัดการการใช้หน่วยความจำ โดยเฉพาะในสภาพแวดล้อมที่จัดการชุดข้อมูลขนาดใหญ่ +- ปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดของ Java สำหรับการจัดการ garbage collection และทรัพยากร เพื่อรักษาประสิทธิภาพของระบบ + +## สรุป +โดยทำตามคู่มือฉบับสมบูรณ์นี้ คุณได้เรียนรู้วิธีการตั้งค่าและเพิ่มประสิทธิภาพเครือข่ายการค้นหาโดยใช้ GroupDocs.Search สำหรับ Java ด้วยทักษะเหล่านี้ คุณพร้อมแล้วที่จะจัดการการค้นหาเอกสารอย่างมีประสิทธิภาพในแอปพลิเคชันต่าง ๆ เพิ่มประสิทธิภาพของโครงการและประสบการณ์ผู้ใช้ของคุณ หากต้องการสำรวจความสามารถของ GroupDocs.Search เพิ่มเติม ให้พิจารณาการบูรณาการกับระบบอื่น ๆ หรือสำรวจฟีเจอร์เพิ่มเติมที่มีในเอกสารของพวกเขา + +## ส่วนคำถามที่พบบ่อย +1. **Shard optimization คืออะไร?** + - การเพิ่มประสิทธิภาพ Shard ช่วยปรับปรุงประสิทธิภาพของเครือข่ายการค้นหาโดยการจัดระเบียบข้อมูลให้มีประสิทธิภาพมากขึ้นในแต่ละ Shard +2. **จะจัดการกับการชนกันของพอร์ตเมื่อกำหนดค่าเครือข่ายการค้นหาอย่างไร?** + - เปลี่ยนตัวแปร `basePort` ไปเป็นพอร์ตที่ยังไม่ได้ใช้บนระบบของคุณและรีสตาร์ทกระบวนการกำหนดค่า +3. **GroupDocs.Search สามารถบูรณาการกับแอปพลิเคชัน Java ที่มีอยู่ได้หรือไม่?** + - ได้ สามารถบูรณาการได้อย่างราบรื่นโดยการเพิ่ม Dependency ของไลบรารีลงในโปรเจกต์ของคุณ +4. **ปัญหาที่พบบ่อยระหว่างการตั้งค่ามีอะไรบ้าง?** + - ปัญหาที่พบบ่อยรวมถึงการกำหนดค่าพอร์ตที่ไม่ถูกต้องและการพึ่งพาไลบรารีที่ขาดหาย; โปรดตรวจสอบให้แน่ใจว่าคุณทำตามข้อกำหนดเบื้องต้นอย่างถูกต้อง + +## คำถามที่พบบ่อยเพิ่มเติม + +**Q: การเพิ่มประสิทธิภาพ Shard มีผลต่อความเร็วของการสืบค้นอย่างไร?** +A: การเพิ่มประสิทธิภาพ Shard ทำให้ดัชนีกระชับ ลดการทำ I/O ของดิสก์ และโดยทั่วไปทำให้การตอบสนองของการสืบค้นเร็วขึ้น + +**Q: ปลอดภัยหรือไม่ที่จะรัน `optimizeShards` บนโหนดที่กำลังทำงาน?** +A: ใช่ การดำเนินการนี้ออกแบบมาให้ทำงานโดยไม่มีการหยุดทำงาน แต่แนะนำให้กำหนดเวลาในช่วงที่มีการใช้งานน้อยสำหรับดัชนีขนาดใหญ่ + +**Q: สามารถปรับแต่ง `OptimizeOptions` ได้หรือไม่?** +A: แน่นอน คุณสามารถตั้งค่าพารามิเตอร์เช่น `maxSegmentSize` หรือ `mergeFactor` เพื่อปรับกระบวนการเพิ่มประสิทธิภาพให้เหมาะสมกับความต้องการของคุณ + +**Q: ควรทำอย่างไรหากพบ `IOException` ระหว่างการเพิ่มประสิทธิภาพ?** +A: ตรวจสอบสิทธิ์ของระบบไฟล์ ตรวจสอบว่ามีพื้นที่ดิสก์เพียงพอ และยืนยันว่าไม่มีกระบวนการอื่นล็อกไฟล์ดัชนี + +**Q: การเพิ่มประสิทธิภาพ Shard ยังช่วยคืนพื้นที่ของเอกสารที่ถูกลบหรือไม่?** +A: ใช่ ตัวเพิ่มประสิทธิภาพจะทำการรวมเซกเมนต์และลบ tombstones ซึ่งทำให้พื้นที่ที่ถูกใช้โดยเอกสารที่ลบแล้วถูกคืนคืน + +--- + +**อัปเดตล่าสุด:** 2026-01-21 +**ทดสอบด้วย:** GroupDocs.Search 25.4 สำหรับ Java +**ผู้เขียน:** GroupDocs \ No newline at end of file