Java pdf arrow annotations – kompletny samouczek i najlepsze praktyki (2025)

Wprowadzenie

Czy kiedykolwiek miałeś problem z tym, aby Twój zespół skupił się na konkretnych fragmentach dokumentu PDF podczas przeglądów? Nie jesteś sam. Niezależnie od tego, czy zarządzasz dokumentacją techniczną, umowami prawnymi czy specyfikacjami projektów, wskazywanie dokładnych obszarów do dyskusji może być frustrujące bez odpowiednich narzędzi.

Oto rozwiązanie: Java PDF arrow annotations przy użyciu GroupDocs.Annotation API. To potężne podejście pozwala programowo add arrow to pdf pliki, zapewniając płynną i profesjonalną współpracę. Możesz uzyskać wersję próbną na stronie GroupDocs tymczasowej licencji.

Szybkie odpowiedzi

  • Jaka biblioteka pozwala dodać strzałkę do PDF w Javie? GroupDocs.Annotation for Java.
  • Czy potrzebuję licencji do produkcji? Tak, licencja komercyjna usuwa znaki wodne i odblokowuje pełny zestaw funkcji. Zobacz stronę cen GroupDocs po szczegóły.
  • Która wersja Javy jest zalecana? JDK 11 oferuje najlepszą wydajność i długoterminowe wsparcie.
  • Czy mogę dodać wiele strzałek w jednym dokumencie? Oczywiście – wystarczy utworzyć wiele obiektów ArrowAnnotation i dodać je do tego samego Annotator.
  • Czy obsługiwane jest przetwarzanie wsadowe? Tak, możesz iterować po dokumentach i ponownie używać tej samej instancji Annotator po odpowiednim zwolnieniu.

Co to jest dodawanie strzałki do PDF?

Operacja add arrow to pdf rysuje wskaźnik kierunkowy na stronie PDF, aby wyróżnić lub wskazać konkretny obszar. Anotacje strzałek są przechowywane jako obiekty PDF, więc pozostają widoczne w każdym zgodnym ze standardem przeglądarce i mogą być później edytowane lub komentowane.

Dlaczego wybrać GroupDocs.Annotation do Java PDF arrow annotations?

GroupDocs.Annotation oferuje bogaty zestaw typów anotacji, wsparcie klasy enterprise oraz prosty interfejs Java API, który redukuje kod szablonowy. W porównaniu z alternatywami przetwarza ponad 50 formatów wejściowych i wyjściowych i może obsłużyć PDF‑y o 500 stronach przy zużyciu pamięci heap poniżej 200 MB, dzięki architekturze strumieniowej.

Wymagania wstępne – czego naprawdę potrzebujesz

Wymagane biblioteki i zależności

Najpierw dodaj zależność Maven GroupDocs.Annotation. Poniższy fragment odzwierciedla dokładne współrzędne, których potrzebujesz; zamień symbol wersji na najnowsze stabilne wydanie.

<repositories>
   <repository>
      <id>repository.groupdocs.com</id>
      <name>GroupDocs Repository</name>
      <url>https://releases.groupdocs.com/annotation/java/</url>
   </repository>
</repositories>
<dependencies>
   <dependency>
      <groupId>com.groupdocs</groupId>
      <artifactId>groupdocs-annotation</artifactId>
      <version>25.2</version>
   </dependency>
</dependencies>

Wskazówka: Sprawdź stronę wydań GroupDocs, aby uzyskać najnowszy numer wersji. Nowe wydania często zawierają poprawki wydajności i dodatkowe style anotacji.

Konfiguracja środowiska, która nie sprawi problemów

  • JDK 8 lub nowszy – JDK 11 jest zalecany ze względu na ulepszony garbage‑collector i system modułów.
  • Maven 3.6+ – starsze wersje Maven mogą mieć problemy z zależnościami tranzytywnymi.
  • IDE – IntelliJ IDEA lub Eclipse zapewniają najlepsze doświadczenie debugowania bibliotek Java.
  • Pamięć – Przydziel co najmniej 2 GB pamięci heap przy pracy z PDF‑ami większymi niż 100 stron.

Wymagania wiedzy (bądź szczery wobec siebie)

Powinieneś być pewny w:

  • Podstawowych kolekcjach Java i obsłudze wyjątków.
  • Zarządzaniu zależnościami Maven.
  • Podstawowym I/O plików (odczyt i zapis strumieni binarnych).

Jeśli którekolwiek z tych obszarów wydaje się niepewne, rozważ szybkie odświeżenie przed zanurzeniem się w kod anotacji.

Konfiguracja GroupDocs.Annotation – właściwy sposób

Krok 1: Konfiguracja Maven (z rozwiązywaniem problemów)

Dodaj repozytorium i zależność pokazane wcześniej. Jeśli Maven nie może rozwiązać artefaktu, upewnij się, że masz zdefiniowane publiczne repozytorium GroupDocs w swoim pom.xml:

<properties>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
</properties>

Krok 2: Konfiguracja licencji (kluczowa dla produkcji)

Do rozwoju możesz użyć tymczasowej licencji próbnej:

// For evaluation purposes
License license = new License();
// license.setLicense("path/to/license.lic"); // Comment this out for trial

Sprawdzenie rzeczywistości: Wersja próbna dodaje widoczny znak wodny do każdego zapisanego PDF. Licencja produkcyjna usuwa ten znak wodny i odblokowuje pełny zestaw funkcji anotacji.

Krok 3: Podstawowy wzorzec inicjalizacji

Annotator jest główną klasą do ładowania dokumentu PDF i stosowania anotacji.
Zawsze otaczaj Annotator blokiem try‑finally, aby zasoby zostały zwolnione niezwłocznie:

Annotator annotator = null;
try {
    annotator = new Annotator("YOUR_DOCUMENT_DIRECTORY/input.pdf");
    // Your annotation code here
} finally {
    if (annotator != null) {
        annotator.dispose();
    }
}

Dlaczego blok try‑finally? GroupDocs przydziela pamięć natywną do parsowania PDF; niezwolnienie Annotator może prowadzić do wycieków pamięci, szczególnie przy przetwarzaniu wielu dokumentów w trybie wsadowym.

Kompletny przewodnik implementacji – od zera do produkcji

Zrozumienie anotacji strzałek w kontekście

Anotacje strzałek działają jako wizualne wskazówki w przepływach przeglądu dokumentów. Typowe przypadki użycia obejmują:

  1. Informacje zwrotne z przeglądu – „Ten punkt wymaga wyjaśnienia.”
  2. Łączenie odniesień – „Zobacz diagram na stronie 12.”
  3. Wskazówki procesowe – „Rozpocznij audyt tutaj.”
  4. Wyróżnianie problemów – „Potencjalny błąd w tym paragrafie.”

Projektowanie interfejsu anotacji wokół tych scenariuszy pomaga użytkownikom szybciej przyjąć narzędzie.

Krok 1: Tworzenie odpowiedzi na anotacje (inteligentny sposób)

Odpowiedzi przekształcają statyczną strzałkę w interaktywny punkt dyskusji. Przy pierwszym użyciu klasy Reply zdefiniuj ją zwięźle:

Definicja: Reply reprezentuje komentarz tekstowy dołączony do anotacji, przechowujący informacje o autorze i znacznik czasu.

Reply reply1 = new Reply();
reply1.setComment("First comment");
reply1.setRepliedOn(Calendar.getInstance().getTime());

Reply reply2 = new Reply();
reply2.setComment("Second comment");
reply2.setRepliedOn(Calendar.getInstance().getTime());

List<Reply> replies = new ArrayList<>();
replies.add(reply1);
replies.add(reply2);

Wskazówka: Przechowuj identyfikator użytkownika i rolę w metadanych odpowiedzi; ułatwi to późniejsze filtrowanie komentarzy.

Krok 2: Tworzenie anotacji strzałki (z uwzględnieniem rzeczywistych warunków)

Definicja: ArrowAnnotation jest obiektem GroupDocs, który renderuje strzałkę kierunkową na stronie PDF.

ArrowAnnotation arrow = new ArrowAnnotation();
arrow.setBox(new Rectangle(100, 100, 100, 100)); // Position and size
arrow.setCreatedOn(Calendar.getInstance().getTime()); // Creation time
arrow.setMessage("This is an arrow annotation"); // Annotation message
arrow.setOpacity(0.7); // Opacity level
arrow.setPageNumber(0); // Page number
arrow.setPenColor(65535); // ARGB pen color
arrow.setPenStyle(PenStyle.DOT); // Pen style
arrow.setPenWidth((byte) 3); // Arrow line width
arrow.setReplies(replies); // Attach replies

Kluczowe parametry wyjaśnione:

  • Współrzędne prostokąta – (x, y, width, height), gdzie (x, y) to lewy górny róg ramki.
  • PenColor – Używa liczby całkowitej ARGB; 65535 daje żywy niebieski. Skorzystaj z konwertera online dla własnych kolorów.
  • PenStyle – Opcje to DOT, DASH, SOLID, DASHDOT, DASHDOTDOT. Wybierz SOLID dla większości zastosowań.
  • Opacity – Zakres od 0.0 (przezroczysty) do 1.0 (nieprzezroczysty). Wartość 0.7 zapewnia równowagę między widocznością a czytelnością zawartości pod spodem.

Krok 3: Dodawanie i zapisywanie (z obsługą błędów)

Definicja: Annotator.save zapisuje wszystkie oczekujące zmiany anotacji do docelowego pliku PDF.

try {
    annotator.add(arrow);
    annotator.save("YOUR_OUTPUT_DIRECTORY/output.pdf");
    System.out.println("Arrow annotation added successfully!");
} catch (Exception e) {
    System.err.println("Failed to add annotation: " + e.getMessage());
    // Log the full stack trace in production
    e.printStackTrace();
} finally {
    annotator.dispose();
}

Zawsze przechwytuj IOException i AnnotationException, aby obsłużyć uszkodzone pliki, nieprawidłowe ścieżki lub problemy z uprawnieniami. Logowanie stosu pomaga diagnozować problemy w produkcji.

Typowe pułapki i jak ich unikać

Problem 1: Współrzędne nie pasują do oczekiwanej pozycji

Problem: Strzałka pojawia się przesunięta względem zamierzonego miejsca.

Rozwiązanie: Origin współrzędnych PDF jest w lewym dolnym rogu, podczas gdy GroupDocs oczekuje lewego górnego. Przelicz współrzędne UI odpowiednio lub użyj wbudowanego pomocnika convertToPdfCoordinates:

// If arrows appear in wrong positions, try adjusting the Y coordinate
int adjustedY = pageHeight - originalY - annotationHeight;
arrow.setBox(new Rectangle(x, adjustedY, width, height));

Problem 2: Anotacje znikają po zapisaniu

Problem: Strzałki pojawiają się podczas przetwarzania, ale brak ich w finalnym PDF.

Rozwiązanie: To prawie zawsze wskazuje na problem z licencją. Upewnij się, że plik licencji jest załadowany przed utworzeniem jakiejkolwiek instancji Annotator:

License license = new License();
try {
    license.setLicense("GroupDocs.Annotation.lic");
} catch (Exception e) {
    System.out.println("License not found, using trial mode");
}

Problem 3: Wycieki pamięci w przetwarzaniu wsadowym

Problem: JVM wyczerpuje pamięć heap przy przetwarzaniu dziesiątek PDF‑ów.

Rozwiązanie: Zwolnij każdy Annotator po zakończeniu pracy z dokumentem i przetwarzaj pliki w małych partiach, aby utrzymać przewidywalne zużycie pamięci:

for (String documentPath : documentPaths) {
    Annotator annotator = null;
    try {
        annotator = new Annotator(documentPath);
        // Process document
    } finally {
        if (annotator != null) {
            annotator.dispose();
        }
    }
    
    // Force garbage collection every 10 documents
    if (processedCount % 10 == 0) {
        System.gc();
    }
}

Zaawansowane techniki dostosowywania

Dynamiczne pozycjonowanie strzałek

Gdy strzałki muszą podążać za kliknięciami użytkownika w interfejsie webowym, oblicz prostokąt po stronie klienta i wyślij współrzędne do backendu. Backend może wtedy utworzyć ArrowAnnotation z tymi wartościami.

public ArrowAnnotation createArrowAt(int x, int y, String message) {
    ArrowAnnotation arrow = new ArrowAnnotation();
    
    // Create arrow pointing to specific coordinates
    int arrowLength = 50;
    arrow.setBox(new Rectangle(x - arrowLength, y - arrowLength, arrowLength, arrowLength));
    arrow.setMessage(message);
    arrow.setOpacity(0.8);
    arrow.setPenColor(0xFF0000); // Red color
    arrow.setPenStyle(PenStyle.SOLID);
    arrow.setPenWidth((byte) 2);
    
    return arrow;
}

Stylowanie strzałek dla różnych przypadków użycia

Możesz zmieniać PenColor i PenStyle, aby przekazać znaczenie — np. czerwone przerywane strzałki dla krytycznych problemów, zielone ciągłe strzałki dla zatwierdzonych sekcji.

// Error highlighting (red, thick, solid)
public ArrowAnnotation createErrorArrow() {
    ArrowAnnotation arrow = new ArrowAnnotation();
    arrow.setPenColor(0xFF0000); // Red
    arrow.setPenWidth((byte) 4);
    arrow.setPenStyle(PenStyle.SOLID);
    arrow.setOpacity(0.9);
    return arrow;
}

// Suggestion arrows (blue, thin, dashed)
public ArrowAnnotation createSuggestionArrow() {
    ArrowAnnotation arrow = new ArrowAnnotation();
    arrow.setPenColor(0x0000FF); // Blue
    arrow.setPenWidth((byte) 2);
    arrow.setPenStyle(PenStyle.DASH);
    arrow.setOpacity(0.6);
    return arrow;
}

Scenariusze implementacji w rzeczywistych projektach

Scenariusz 1: System przeglądu dokumentów

W wieloużytkownikowym portalu przeglądu każdy recenzent tworzy ArrowAnnotation i dołącza Reply. System przechowuje odpowiedzi w relacyjnej bazie danych, umożliwiając wątkową dyskusję przy każdej anotacji.

public class DocumentReviewSystem {
    public void addReviewArrow(String documentPath, int x, int y, 
                              String reviewComment, String reviewerName) {
        Annotator annotator = new Annotator(documentPath);
        
        ArrowAnnotation arrow = new ArrowAnnotation();
        arrow.setBox(new Rectangle(x, y, 50, 50));
        arrow.setMessage("Review by " + reviewerName);
        
        // Add reviewer's comment as reply
        Reply review = new Reply();
        review.setComment(reviewComment);
        review.setUser(new User(reviewerName));
        review.setRepliedOn(new Date());
        
        arrow.setReplies(Arrays.asList(review));
        
        annotator.add(arrow);
        annotator.save(documentPath.replace(".pdf", "_reviewed.pdf"));
        annotator.dispose();
    }
}

Scenariusz 2: Automatyczne wykrywanie problemów

Silnik analizy skanuje PDF‑y pod kątem naruszeń zgodności i automatycznie wstawia czerwone strzałki wskazujące problematyczne klauzule.

public void highlightDetectedIssues(String documentPath, List<Issue> issues) {
    Annotator annotator = new Annotator(documentPath);
    
    for (Issue issue : issues) {
        ArrowAnnotation arrow = createArrowForIssue(issue);
        annotator.add(arrow);
    }
    
    annotator.save(documentPath.replace(".pdf", "_issues_highlighted.pdf"));
    annotator.dispose();
}

private ArrowAnnotation createArrowForIssue(Issue issue) {
    ArrowAnnotation arrow = new ArrowAnnotation();
    arrow.setBox(new Rectangle(issue.getX(), issue.getY(), 40, 40));
    arrow.setMessage("Issue detected: " + issue.getType());
    
    // Color‑code by severity
    switch (issue.getSeverity()) {
        case HIGH:
            arrow.setPenColor(0xFF0000); // Red
            break;
        case MEDIUM:
            arrow.setPenColor(0xFFA500); // Orange
            break;
        case LOW:
            arrow.setPenColor(0xFFFF00); // Yellow
            break;
    }
    
    return arrow;
}

Wskazówki optymalizacji wydajności

Najlepsze praktyki zarządzania pamięcią

  1. Use try‑with‑resources (Java 7+) to auto‑close Annotator objects:

try (Annotator annotator = new Annotator(“document.pdf”)) { // Your annotation code } // Automatically disposed


2. **Process pages individually** instead of loading the entire document into memory.  

3. **Monitor heap usage** with tools like VisualVM or JConsole during large‑scale batch runs.

### Rozważania dotyczące wydajności CPU

- Ponownie używaj jednej instancji `Color` dla wszystkich strzałek, aby uniknąć niepotrzebnego przydzielania obiektów.  
- Unikaj zagnieżdżonych pętli, które wielokrotnie tworzą identyczne obiekty `PenStyle`.  
- Jeśli masz wiele niezależnych PDF‑ów, rozważ pulę wątków, ale ogranicz liczbę jednoczesnych instancji `Annotator`, aby kontrolować zużycie pamięci.

## Przewodnik rozwiązywania problemów – rozwiązania rzeczywistych problemów

### Problem: Anotacje niewidoczne w Adobe Reader

**Objawy**: Strzałki pojawiają się w Twoim własnym podglądzie, ale nie w Adobe Acrobat.

**Rozwiązania**:

1. Zapisz PDF z zgodnością PDF/A‑1b, aby zapewnić maksymalną kompatybilność podglądarki:  

   ```java
// Try different save options if available
SaveOptions saveOptions = new SaveOptions();
saveOptions.setAnnotationType(AnnotationType.All);
annotator.save(outputPath, saveOptions);
  1. Zweryfikuj, że wersja PDF wynosi co najmniej 1.7; starsze wersje mogą pomijać nowsze typy anotacji.

Problem: Słaba wydajność przy dużych PDF‑ach

Objawy: Aplikacja się zawiesza lub staje się nieodpowiadająca przy obsłudze PDF‑ów powyżej 200 stron.

Rozwiązania:

  1. Process pages individually rather than loading the whole file:

// Process specific pages LoadOptions loadOptions = new LoadOptions(); loadOptions.setLoadCharts(false); // Skip charts if not needed Annotator annotator = new Annotator(documentPath, loadOptions);


2. **Enable streaming** in the `Annotator` constructor if your version supports it.  

3. Increase the JVM heap (`-Xmx4g`) for very large documents.

### Problem: Problemy z renderowaniem kolorów

**Objawy**: Strzałka jest szara lub całkowicie przezroczysta.

**Rozwiązanie**: Define the color using the ARGB format and ensure the PDF’s color space is set to **DeviceRGB**:

```java
// Use hex values for consistent colors
int red = 0xFFFF0000;    // ARGB format
int blue = 0xFF0000FF;
int green = 0xFF00FF00;

// Or convert from RGB
public int rgbToArgb(int r, int g, int b) {
    return (0xFF << 24) | (r << 16) | (g << 8) | b;
}

Testowanie implementacji

Testy jednostkowe anotacji strzałek

Solidny test jednostkowy ładuje przykładowy PDF, dodaje ArrowAnnotation, zapisuje plik, a następnie ponownie otwiera go, aby zweryfikować liczbę anotacji i ich właściwości:

@Test
public void testArrowAnnotationCreation() {
    // Arrange
    String inputPath = "test-documents/sample.pdf";
    String outputPath = "test-output/annotated.pdf";
    
    // Act
    Annotator annotator = new Annotator(inputPath);
    ArrowAnnotation arrow = new ArrowAnnotation();
    arrow.setBox(new Rectangle(100, 100, 50, 50));
    arrow.setMessage("Test annotation");
    
    annotator.add(arrow);
    annotator.save(outputPath);
    annotator.dispose();
    
    // Assert
    assertTrue("Output file should exist", new File(outputPath).exists());
    
    // Verify annotation was added
    Annotator verifyAnnotator = new Annotator(outputPath);
    List<AnnotationInfo> annotations = verifyAnnotator.get();
    assertEquals("Should have one annotation", 1, annotations.size());
    verifyAnnotator.dispose();
}

Testy integracyjne

Uruchom ten sam zestaw testów przeciwko PDF‑om o różnych rozmiarach (10 stron, 100 stron, 500 stron) i na różnych przeglądarkach (Adobe Reader, Foxit, Chrome), aby zapewnić spójne renderowanie.

Zakończenie

Masz teraz kompletny zestaw narzędzi do implementacji Java PDF arrow annotations przy użyciu GroupDocs.Annotation. Pamiętaj, aby:

  • Zwalniać obiekty Annotator niezwłocznie.
  • Testować z różnorodnymi wersjami i rozmiarami PDF.
  • Stosować wskazówki dotyczące wydajności przy skalowaniu do zadań wsadowych.
  • Stylizować strzałki, aby odzwierciedlały semantyczne znaczenie każdego komentarza.

Kolejne kroki: zapoznaj się z innymi typami anotacji, takimi jak TextAnnotation, AreaAnnotation i WatermarkAnnotation. Te same wzorce inicjalizacji i zwalniania mają zastosowanie, umożliwiając budowę w pełni funkcjonalnej platformy współpracy nad dokumentami.

Najczęściej zadawane pytania

Q: Czy mogę dodać anotacje strzałek do PDF‑ów zabezpieczonych hasłem?
A: Tak, podaj hasło przy tworzeniu instancji Annotator:

LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your-password");
Annotator annotator = new Annotator("protected.pdf", loadOptions);

Q: Jak efektywnie przetwarzać wiele dokumentów wsadowo?
A: Przetwarzaj dokumenty w małych partiach, ponownie używaj jednej instancji Annotator na plik i wywołuj dispose() po każdym zapisie:

for (String doc : documents) {
    try (Annotator annotator = new Annotator(doc)) {
        // Add annotations
        annotator.save(doc.replace(".pdf", "_annotated.pdf"));
    }
    if (processedCount % 10 == 0) {
        System.gc(); // Encourage garbage collection
    }
}

Q: Jaka jest maksymalna liczba anotacji w dokumencie?
A: GroupDocs nie narzuca sztywnego limitu, ale praktyczna wydajność spada po około 1 000 anotacji w PDF‑ie o 500 stronach, chyba że zastosujesz opisane wcześniej techniki zarządzania pamięcią.

Q: Czy mogę dostosować kształty strzałek poza standardowymi opcjami?
A: Biblioteka udostępnia standardowe groty strzałek. Aby uzyskać w pełni niestandardowe kształty, możesz łączyć wiele obiektów AreaAnnotation lub przejść do biblioteki skoncentrowanej na grafice, obsługującej ścieżki wektorowe.

Q: Jak obsługiwać różne systemy współrzędnych PDF?
A: GroupDocs automatycznie konwertuje między współrzędnymi UI (lewy górny) a współrzędnymi PDF (lewy dolny). Jeśli napotkasz niezgodności, sprawdź, czy nie stosujesz dodatkowej warstwy transformacji po stronie klienta.

// Get page info for coordinate calculations
PageInfo pageInfo = annotator.getDocument().getPages().get(pageNumber);
int pageHeight = pageInfo.getHeight();

// Adjust Y coordinate if needed
int adjustedY = pageHeight - originalY;

Q: Jaki jest koszt licencji na produkcję?
A: GroupDocs oferuje licencje Developer, Site i OEM. Ceny zaczynają się od $699 za miejsce dewelopera rocznie. Odwiedź stronę cen GroupDocs, aby poznać aktualne stawki.

Q: Jak zintegrować to z aplikacjami Spring Boot?
A: Utwórz bean @Service, który enkapsuluje logikę anotacji, wstrzyknij go do kontrolerów i udostępnij endpoint REST przyjmujący strumień PDF i zwracający oznaczony PDF.

@Service
public class AnnotationService {
    public void addArrowAnnotation(String inputPath, String outputPath, 
                                 int x, int y, String message) {
        try (Annotator annotator = new Annotator(inputPath)) {
            ArrowAnnotation arrow = new ArrowAnnotation();
            arrow.setBox(new Rectangle(x, y, 50, 50));
            arrow.setMessage(message);
            
            annotator.add(arrow);
            annotator.save(outputPath);
        }
    }
}

Q: Czy mogę wyodrębnić istniejące anotacje strzałek z PDF‑ów?
A: Tak, wywołaj metodę getAnnotations() na instancji Annotator i przefiltruj wyniki po AnnotationType.Arrow.

Annotator annotator = new Annotator("document.pdf");
List<AnnotationInfo> annotations = annotator.get();

for (AnnotationInfo annotation : annotations) {
    if (annotation instanceof ArrowAnnotation) {
        ArrowAnnotation arrow = (ArrowAnnotation) annotation;
        System.out.println("Arrow message: " + arrow.getMessage());
    }
}

Dodatkowe zasoby

Ostatnia aktualizacja: 2026-08-14
Testowano z: GroupDocs.Annotation 25.2 for Java
Autor: GroupDocs

public void processBatch(List<String> documents, int batchSize) {
    for (int i = 0; i < documents.size(); i += batchSize) {
        List<String> batch = documents.subList(i, 
            Math.min(i + batchSize, documents.size()));
        
        processBatchInternal(batch);
        
        // Allow GC between batches
        System.gc();
        Thread.sleep(100);
    }
}

Runtime runtime = Runtime.getRuntime();
long memoryBefore = runtime.totalMemory() - runtime.freeMemory();

// Your annotation processing

long memoryAfter = runtime.totalMemory() - runtime.freeMemory();
System.out.println("Memory used: " + (memoryAfter - memoryBefore) + " bytes");

java -Xmx4g -jar your-application.jar

Powiązane tutoriale