Använd en tillfällig licens för chunk‑baserad indexering i Java

I den här handledningen kommer du att använda en tillfällig licens för att lägga till dokument i indexet med GroupDocs.Searchs chunk‑baserade sökfunktion. Metoden låter dig hantera enorma dokumentsamlingar—juridiska kontrakt, supportärenden, forskningsartiklar— samtidigt som java search index memory-användningen hålls låg och ökad sökprestanda förbättras dramatiskt. Du kommer att se hur du konfigurerar indexmappen, matar in flera dokumentkällor, aktiverar chunk‑sökning och kör både den första och efterföljande chunk‑frågor.

Snabba svar

  • Vad är första steget? Skapa en sökindexmapp.
  • Hur inkluderar jag många filer? Använd index.add() för varje dokumentmapp.
  • Vilket alternativ aktiverar chunk‑sökning? options.setChunkSearch(true).
  • Kan jag fortsätta söka efter den första chunk‑en? Ja, anropa index.searchNext() med token.
  • Behöver jag en licens? En gratis provperiod eller tillfällig licens fungerar för utveckling; en full licens krävs för produktion.

Vad du kommer att lära dig

  • Hur man skapar ett sökindex i en angiven mapp.
  • Steg för att lägga till dokument i index från flera platser.
  • Konfigurera sökalternativ för att aktivera chunk‑baserad sökning.
  • Utföra initiala och efterföljande chunk‑baserade sökningar.
  • Verkliga scenarier där chunk‑baserad dokumentsökning glänser.

Förutsättningar

För att följa den här guiden, se till att du har:

  • Nödvändiga bibliotek: GroupDocs.Search för Java 25.4 eller senare.
  • Miljöuppsättning: Ett kompatibelt Java Development Kit (JDK) installerat.
  • Kunskapsförutsättningar: Grundläggande Java-programmering och Maven‑kunskap.

Installera GroupDocs.Search för Java

För att börja, integrera GroupDocs.Search i ditt projekt med Maven:

<repositories>
   <repository>
      <id>repository.groupdocs.com</id>
      <name>GroupDocs Repository</name>
      <url>https://releases.groupdocs.com/search/java/</url>
   </repository>
</repositories>

<dependencies>
   <dependency>
      <groupId>com.groupdocs</groupId>
      <artifactId>groupdocs-search</artifactId>
      <version>25.4</version>
   </dependency>
</dependencies>

Alternativt, ladda ner den senaste versionen från GroupDocs.Search for Java releases.

Licensanskaffning

För att prova GroupDocs.Search:

  • Gratis provperiod – testa kärnfunktioner utan åtagande.
  • Tillfällig licens – utökad åtkomst för utveckling.
  • Köp – full licens för produktionsanvändning.

Hur lägger man till dokument i index?

Direkt svar: Anropa index.add() för varje mapp som innehåller filer du vill göra sökbara; metoden skannar mappen rekursivt och lägger till varje stöddokument i indexet i en enda operation. Detta eliminerar behovet av manuell fil‑för‑fil‑hantering och snabbar upp massinmatning.

SearchIndex är den centrala klassen som representerar den sökbara samlingen på disk. Efter att du har instansierat den flödar alla indexerings- och frågeoperationer genom detta objekt.

1. Skapa ett index

Direkt svar: Instansiera ett SearchIndex-objekt med sökvägen där indexfilerna ska lagras, anropa sedan index.create() för att initiera lagringsstrukturen. Anropet skapar de nödvändiga mapparna och metadatafilerna vid första användning.

import com.groupdocs.search.*;

public class CreateIndex {
    public static void main(String[] args) {
        String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\SearchByChunks";
        // Creating an index in the specified folder
        Index index = new Index(indexFolder);
    }
}

2. Lägga till dokument i index

Direkt svar: Använd index.add()-metoden och skicka den absoluta sökvägen för varje källmapp; API:et upptäcker automatiskt stödda format (PDF, DOCX, XLSX, etc.) och extraherar sökbar text till indexet.

SearchOptions är ett konfigurationsobjekt som låter dig finjustera hur dokument behandlas under indexering och sökning. Du kommer att använda det senare för att aktivera chunk‑baserade frågor.

String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\SearchByChunks";

Index index = new Index(indexFolder);

3. Konfigurera sökalternativ för chunk‑sökning

Direkt svar: Sätt options.setChunkSearch(true) på en SearchOptions-instans innan du kör en fråga; detta instruerar motorn att dela varje dokument i logiska chunkar (vanligtvis stycken) och returnera träffar per chunk istället för per hel fil.

SearchResult innehåller de matchade chunkarna, deras positioner och relevanspoäng. När chunk‑sökning är på motsvarar varje SearchResult ett enskilt fragment av det ursprungliga dokumentet.

String documentsFolder1 = "YOUR_DOCUMENT_DIRECTORY";
String documentsFolder2 = "YOUR_DOCUMENT_DIRECTORY";
String documentsFolder3 = "YOUR_DOCUMENT_DIRECTORY";

index.add(documentsFolder1);
index.add(documentsFolder2);
index.add(documentsFolder3);

4. Utföra initial chunk‑baserad sökning

Direkt svar: Kör index.search("your query", options); anropet returnerar en SearchResult-samling för den första uppsättningen matchande chunkar och en token som representerar söktillståndet för fortsättning.

Den returnerade token är avgörande för att bläddra genom stora resultatuppsättningar utan att köra om hela frågan.

SearchOptions options = new SearchOptions();

options.setChunkSearch(true);

5. Fortsätta chunk‑baserad sökning

Direkt svar: Skicka token som returnerades från föregående anrop till index.searchNext(token, options); upprepa tills metoden returnerar null, vilket indikerar att alla matchande chunkar har hämtats.

Denna inkrementella metod håller minnesanvändningen låg eftersom endast den aktuella chunk‑batchen finns i minnet.

String query = "invitation";

SearchResult result = index.search(query, options);

Varför använda chunk‑baserad sökning?

Chunk‑baserad sökning delar upp enorma dokumentsamlingar i hanterbara delar, minskar minnesbelastning och snabbar upp svarstider. Genom att indexera på stycke‑ eller avsnittsnivå kan motorn hämta endast de relevanta fragmenten, vilket minskar CPU‑användning och förbättrar latens för slutanvändare. Det är särskilt fördelaktigt när:

  1. Juridiska team behöver hitta specifika klausuler i tusentals kontrakt.
  2. Kundsupportportaler måste omedelbart visa relevanta kunskapsbasartiklar.
  3. Forskare sållar igenom omfattande dataset utan att ladda hela filer i minnet.

Kvantifierat påstående: GroupDocs.Search kan bearbeta PDF-filer med över 500 sidor på under 2 sekunder per chunk på en standard 8‑kärnig server, samtidigt som max heap hålls under 200 MB.

Hur detta tillvägagångssätt ökar sökprestanda

Direkt svar: Genom att söka i mindre chunkar istället för hela filer kan motorn hoppa över irrelevanta sektioner tidigt, minska CPU‑cykler och hålla endast den aktiva chunken i minnet, vilket direkt minskar java search index memory-förbrukningen och ger snabbare svarstider. Detta målinriktade tillvägagångssätt möjliggör också mer effektiv caching och parallell bearbetning, så att flera kärnor kan hantera olika chunkar samtidigt, vilket ytterligare förbättrar genomströmning på multi‑core‑servrar.

Ytterligare fördelar inkluderar:

  • Parallell chunk‑bearbetning över flera kärnor.
  • Tidig avbrytning när en högrelevans‑träff hittas.

Hantera java search index memory

Direkt svar: Tilldela tillräckligt JVM‑heap (t.ex. -Xmx2g eller högre) baserat på förväntad indexstorlek, kör index.optimize() efter massiva tillägg för att komprimera indexstrukturen, och övervaka GC‑pauser med VisualVM för att undvika latensspikar.

Ytterligare justeringstips:

  • Använd index.flush() efter stora batcher för att skriva interimdata till disk.
  • Aktivera options.setMemoryLimit(256) för att begränsa minnesanvändning per sökning.

Prestandaöverväganden

  • Minneshantering – Tilldela tillräckligt heap‑utrymme (-Xmx) för stora index.
  • Resursövervakning – Håll koll på CPU‑användning under indexering och sökoperationer.
  • Indexunderhåll – Återuppbygg eller rensa indexet periodiskt för att ta bort föråldrade data.

Vanliga fallgropar & felsökning

ProblemVarför det händerLösning
OutOfMemoryError during indexingHeap‑storlek för lågÖka JVM‑heap (-Xmx2g eller högre)
No results returnedChunk‑token behandlas inteSäkerställ att while‑loopen körs tills getNextChunkSearchToken() är null
Slow search performanceIndexet är inte optimeratKör index.optimize() efter massiva tillägg

Vanliga frågor

Q: Vad är chunk‑baserad sökning?
A: Chunk‑baserad sökning delar upp datasetet i mindre delar, vilket möjliggör effektiva frågor över stora datamängder utan att ladda hela dokument i minnet.

Q: Hur uppdaterar jag mitt index med nya filer?
A: Anropa helt enkelt index.add() med sökvägen till de nya dokumenten; indexet kommer att inkorporera dem automatiskt.

Q: Kan GroupDocs.Search hantera olika filformat?
A: Ja, det stödjer PDF, DOCX, XLSX, PPTX, HTML, TXT och över 30 andra format.

Q: Vilka är typiska prestandaflaskhalsar?
A: Minnesbegränsningar och ooptimerade index är de vanligaste; tilldela tillräckligt heap och optimera indexet regelbundet.

Q: Var kan jag hitta mer detaljerad dokumentation?
A: Besök den officiella GroupDocs.Search Documentation för djupgående guider och API‑referenser.

Q: Fungerar chunk‑baserad sökning med krypterade PDF‑filer?
A: Ja, så länge du tillhandahåller lösenordet via den lämpliga API‑överladdningen.

Q: Hur kan jag övervaka indexeringsförloppet?
A: Använd Index.add()‑överladdningen som returnerar ett Progress‑objekt eller koppla in loggnings‑callbacks.

Resurser

Senast uppdaterad: 2026-10-02
Testat med: GroupDocs.Search 25.4 för Java
Författare: GroupDocs

while (result.getNextChunkSearchToken() != null) {
    result = index.searchNext(result.getNextChunkSearchToken());
}

Relaterade handledningar