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 projektowymi, wskazywanie dokładnych obszarów do dyskusji może być frustrujące bez odpowiednich narzędzi.

Oto rozwiązanie: adnotacje strzałek w PDF przy użyciu API GroupDocs.Annotation. To potężne podejście pozwala programowo dodawać strzałki do plików PDF, zapewniając płynną i profesjonalną współpracę.

W tym obszernej przewodniku dowiesz się, jak wdrożyć adnotacje strzałek, które naprawdę działają w środowiskach produkcyjnych. Omówimy wszystko, od podstawowej konfiguracji po zaawansowaną personalizację, a także scenariusze z rzeczywistego świata, które możesz napotkać (i jak sobie z nimi radzić).

Co wyróżnia ten samouczek? Otrzymasz praktyczne wskazówki od kogoś, kto wdrażał to w aplikacjach korporacyjnych, w tym pułapki, o których dokumentacja nie wspomina.

Szybkie Odpowiedzi

Jaką bibliotekę mogę użyć, aby dodać strzałkę do PDF w Javie? GroupDocs.Annotation for Java.
Czy potrzebna jest licencja do produkcji? Tak, licencja komercyjna usuwa znaki wodne.
Jaka wersja Javy jest zalecana? JDK 11 zapewnia najlepszą wydajność.
Czy mogę dodać wiele strzałek w jednym dokumencie? Oczywiście – wystarczy utworzyć wiele obiektów ArrowAnnotation.
Czy obsługiwane jest przetwarzanie wsadowe? Tak, przetwarzaj dokumenty w pętlach i zwalniaj obiekty Annotator.

Co to jest dodawanie strzałki do PDF?

Dodanie adnotacji strzałki oznacza programowe rysowanie wskaźnika kierunkowego na stronie PDF. Pomaga recenzentom wskazywać fragmenty, podkreślać problemy lub prowadzić czytelników przez proces bez ręcznej edycji pliku.

Dlaczego wybrać GroupDocs.Annotation do adnotacji strzałek w PDF w Javie?

Zanim zagłębimy się w kod, porozmawiajmy o najważniejszej kwestii: dlaczego używać GroupDocs, gdy dostępne są inne biblioteki do adnotacji PDF?

Szczera porównanie:

iText: Świetny do podstawowych adnotacji, ale personalizacja strzałek jest ograniczona
PDFBox: Darmowy i wydajny, ale wymaga więcej kodu szablonowego
GroupDocs.Annotation: Najlepszy kompromis między funkcjami a łatwością użycia (choć jest komercyjny)

GroupDocs wyróżnia się, gdy potrzebujesz:

Wielu typów adnotacji w jednym projekcie
Wsparcia i dokumentacji na poziomie korporacyjnym
Szybkiej implementacji przy minimalnym kodzie
Wbudowanych funkcji współpracy (np. odpowiedzi)

Uczciwe ostrzeżenie: Nie jest darmowy. Jednak jeśli tworzysz aplikację komercyjną, w której liczy się czas wprowadzenia na rynek, inwestycja zazwyczaj zwraca się dzięki skróceniu czasu developmentu.

Wymagania wstępne – Czego naprawdę potrzebujesz

Przejdźmy do praktyki – co naprawdę potrzebujesz przed rozpoczęciem. Widziałem zbyt wielu programistów, którzy zaczynają bez odpowiedniej konfiguracji i tracą godziny na problemy konfiguracyjne.

Wymagane biblioteki i zależności

Najpierw musisz dodać GroupDocs.Annotation do swojego projektu Maven. Oto konfiguracja, która naprawdę działa (testowałem ją w wielu projektach):

<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: Zawsze sprawdzaj najnowszą wersję na ich stronie wydań. Wersja 25.2 jest aktualna w momencie pisania, ale nowsze wersje często zawierają ważne poprawki błędów.

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

Oto, czego potrzebujesz, aby mieć płynne doświadczenie deweloperskie:

JDK 8 lub nowszy (polecam JDK 11 dla lepszej wydajności)
Maven 3.6+ (starsze wersje czasami mają problemy z rozwiązywaniem zależności)
IDE: IntelliJ IDEA lub Eclipse (VS Code też działa, ale debugowanie jest łatwiejsze w dedykowanych IDE Java)
Pamięć: Upewnij się, że JVM ma co najmniej 2 GB pamięci heap do przetwarzania dużych PDF‑ów

Wymagania wiedzy (bądź szczery wobec siebie)

Powinieneś być zaznajomiony z:

Podstawowym programowaniem w Javie (kolekcje, obsługa wyjątków)
Zarządzaniem zależnościami Maven
Operacjami I/O na plikach w Javie

Jeśli jesteś nowy w którejkolwiek z tych dziedzin, nie ma problemu – po prostu spodziewaj się poświęcić dodatkowy czas na te aspekty.

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

Oto jak poprawnie skonfigurować GroupDocs.Annotation, włączając kroki, które dokumentacja często pomija.

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

Dodaj repozytorium i zależność z powyższego. Jeśli napotkasz problemy z rozwiązywaniem zależności (co zdarza się czasami), spróbuj dodać to do swojego pom.xml:

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

Krok 2: Konfiguracja licencji (kluczowe dla produkcji)

Do rozwoju i testów:

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

Rzeczywistość: Wersja próbna dodaje znaki wodne do Twojego wyjścia. Do produkcji potrzebna będzie odpowiednia licencja od GroupDocs.

Krok 3: Podstawowy wzorzec inicjalizacji

Zawsze używaj tego wzorca do inicjalizacji annotatora:

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? Zaufaj mi – obiekty GroupDocs wymagają prawidłowego zwalniania, aby zapobiec wyciekom pamięci, szczególnie przy przetwarzaniu wielu dokumentów.

Kompletny przewodnik implementacji – od zera do produkcji

Zbudujmy implementację adnotacji strzałek w rzeczywistym świecie, którą możesz faktycznie używać w produkcji.

Zrozumienie adnotacji strzałek w kontekście

Adnotacje strzałek nie są tylko ozdobą – to narzędzia komunikacji. W przepływach dokumentów zazwyczaj spełniają następujące cele:

Informacje zwrotne z przeglądu – „Ten fragment wymaga korekty”
Łączenie odniesień – „Zobacz powiązaną treść tutaj”
Wskazówki procesowe – „Rozpocznij przegląd od tego punktu”
Wyróżnianie problemów – „Problem zidentyfikowany w tym obszarze”

Zrozumienie kontekstu pomaga zaprojektować lepsze systemy adnotacji.

Krok 1: Tworzenie odpowiedzi do adnotacji (inteligentny sposób)

Odpowiedzi sprawiają, że Twoje adnotacje są interaktywne. Oto jak tworzyć znaczące odpowiedzi:

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);

Najlepsza praktyka: Dołącz informacje o użytkowniku w odpowiedziach, aby lepiej śledzić współpracę. W produkcji zazwyczaj pobierasz je z systemu zarządzania użytkownikami.

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

Oto podstawowa implementacja z wyjaśnieniami dla każdego parametru:

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

Rozłóżmy trudne części:

Współrzędne prostokąta: (x, y, width, height), gdzie x,y to lewy górny róg
PenColor: Używa formatu ARGB. 65535 to jasny niebieski. Skorzystaj z internetowych konwerterów kolorów, aby uzyskać własne kolory
Opcje PenStyle: DOT, DASH, SOLID, DASHDOT, DASHDOTDOT
Opacity: 0.0 (przezroczyste) do 1.0 (nieprzezroczyste). 0.7 zazwyczaj jest idealne dla widoczności bez bycia nachalnym

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

Oto gotowy do produkcji sposób dodawania adnotacji:

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();
}

Kluczowy punkt: Zawsze obsługuj wyjątki przy operacjach na plikach. PDF‑y mogą być uszkodzone, ścieżki nieprawidłowe, a uprawnienia mogą powodować problemy.

Typowe pułapki i jak ich unikać

Po wdrożeniu tego w kilku projektach, oto problemy, które najprawdopodobniej napotkasz:

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

Problem: Twoja strzałka pojawia się w niewłaściwym miejscu w PDF.

Rozwiązanie: System współrzędnych PDF zaczyna się od lewego dolnego rogu, ale większość bibliotek adnotacji używa lewego górnego rogu. GroupDocs obsługuje tę konwersję, ale możesz potrzebować dostosować w zależności od charakterystyki Twojego PDF.

// 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: Adnotacje znikają po zapisaniu

Problem: Adnotacje pojawiają się podczas przetwarzania, ale znikają w finalnym PDF.

Rozwiązanie: Zazwyczaj problem z licencją. Upewnij się, że licencja jest prawidłowo załadowana:

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 przy przetwarzaniu wsadowym

Problem: Aplikacja wyczerpuje pamięć przy przetwarzaniu wielu dokumentów.

Rozwiązanie: Zawsze zwalniaj obiekty annotatora i rozważ przetwarzanie dokumentów w partiach:

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 personalizacji

Dynamiczne pozycjonowanie strzałek

W aplikacjach interaktywnych możesz potrzebować pozycjonować strzałki na podstawie danych od użytkownika:

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

// 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 rzeczywistym świecie

Scenariusz 1: System przeglądu dokumentów

Budujesz system przeglądu dokumentów, w którym wielu użytkowników może dodawać opinie:

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

Integracja z narzędziami analitycznymi w celu automatycznego podświetlania potencjalnych problemów:

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ą

Podczas przetwarzania dużych dokumentów lub wielu plików:

Użyj wzorca try‑with‑resources (jeśli Twoja wersja go obsługuje):

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

Przetwarzaj w partiach:

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);
    }
}

Monitoruj zużycie pamięci:

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");

Rozważania dotyczące wydajności CPU

Unikaj niepotrzebnego tworzenia obiektów w pętlach
Ponownie używaj obiektów koloru i stylu, gdy to możliwe
Rozważ przetwarzanie równoległe niezależnych dokumentów (ale kontroluj zużycie pamięci)

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

Problem: Adnotacje niewidoczne w Adobe Reader

Objawy: Adnotacje są widoczne w Twojej aplikacji, ale nie w Adobe Reader ani innych przeglądarkach PDF.

Rozwiązania:

Upewnij się, że zapisujesz zgodnie z odpowiednimi standardami PDF:

// Try different save options if available
SaveOptions saveOptions = new SaveOptions();
saveOptions.setAnnotationType(AnnotationType.All);
annotator.save(outputPath, saveOptions);

Sprawdź kompatybilność wersji PDF – starsze wersje PDF mogą nie obsługiwać wszystkich funkcji adnotacji.

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

Objawy: Aplikacja staje się wolna lub nieodpowiadająca przy dużych dokumentach.

Rozwiązania:

Przetwarzaj strony indywidualnie zamiast całego dokumentu:

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

Używaj strumieniowania, gdy to możliwe, dla bardzo dużych plików.
Zwiększ rozmiar pamięci heap JVM:

java -Xmx4g -jar your-application.jar

Problem: Problemy z renderowaniem kolorów

Objawy: Kolory wyglądają inaczej niż oczekiwano w finalnym PDF.

Rozwiązanie: Użyj prawidłowych definicji przestrzeni kolorów:

// 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 Twojej implementacji

Testy jednostkowe adnotacji strzałek

Oto praktyczna struktura testu:

@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

Testuj z różnymi typami i rozmiarami PDF, aby upewnić się, że implementacja działa w różnych scenariuszach.

Zakończenie

Masz teraz kompletny zestaw narzędzi do implementacji adnotacji strzałek w PDF w Javie przy użyciu GroupDocs.Annotation. To nie tylko dodawanie strzałek do PDF‑ów – to budowanie solidnych funkcji współpracy nad dokumentami, które naprawdę działają w produkcji.

Kluczowe wnioski z tego przewodnika:

Zawsze prawidłowo zarządzaj zasobami (używaj bloków try‑finally)
Testuj z różnymi typami i rozmiarami PDF
Rozważ zarządzanie pamięcią przy przetwarzaniu wsadowym
Wdrażaj odpowiednią obsługę błędów w środowisku produkcyjnym
Stylizuj adnotacje odpowiednio do ich przeznaczenia

Twoje kolejne kroki: Zacznij od prostego prototypu używając podstawowej implementacji, a następnie stopniowo dodawaj zaawansowane funkcje, takie jak dynamiczne pozycjonowanie i niestandardowe stylowanie, w miarę rozwoju wymagań.

Gotowy, aby iść dalej? Poznaj inne funkcje GroupDocs.Annotation, takie jak adnotacje tekstowe, obszarowe i znaki wodne. Wzorce, których się nauczyłeś, mają zastosowanie do wszystkich typów adnotacji.

Najczęściej zadawane pytania

P: Czy mogę dodać adnotacje strzałek do zabezpieczonych hasłem PDF‑ów?
O: Tak, ale musisz podać hasło przy tworzeniu Annotatora:

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

P: Jak efektywnie przetwarzać wsadowo wiele dokumentów?
O: Przetwarzaj dokumenty w małych partiach i prawidłowo zwalniaj zasoby:

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
    }
}

P: Jaka jest maksymalna liczba adnotacji w dokumencie?
O: GroupDocs nie narzuca sztywnego limitu, ale praktyczne ograniczenia zależą od pamięci, możliwości przeglądarki PDF oraz wymagań wydajnościowych. Przy dużych liczbach (1000+), zastosuj techniki optymalizacji wydajności omówione wcześniej.

P: Czy mogę dostosować kształty strzałek poza standardowymi opcjami?
O: GroupDocs.Annotation oferuje standardowe kształty strzałek. Aby uzyskać niestandardowe kształty, możesz potrzebować użyć adnotacji obszarowych, połączyć kilka prostych adnotacji lub przejść do bardziej wyspecjalizowanej biblioteki graficznej.

P: Jak radzić sobie z różnymi systemami współrzędnych PDF?
O: GroupDocs zazwyczaj automatycznie konwertuje współrzędne. Jeśli napotkasz problemy:

// 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;

P: Jaki jest koszt licencji do użytku produkcyjnego?
O: GroupDocs oferuje różne modele licencjonowania (Developer, Site, OEM). Sprawdź najnowsze stawki na stronie cenowej GroupDocs.

P: Jak zintegrować to z aplikacjami Spring Boot?
O: Utwórz klasę serwisową dla operacji adnotacji:

@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);
        }
    }
}

P: Czy mogę wyodrębnić istniejące adnotacje strzałek z PDF‑ów?
O: Tak, użyj metody get(), aby pobrać istniejące adnotacje:

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

Dokumentacja: GroupDocs.Annotation for Java Documentation
Referencja API: Complete API Reference
Pobierz najnowszą wersję: GroupDocs Releases
Kup licencję: Buy GroupDocs License
Darmowa wersja próbna: Download Free Trial
Licencja tymczasowa: Request Temporary License
Wsparcie społeczności: GroupDocs Forum
Wsparcie profesjonalne: Dostępne w płatnych licencjach jako priorytetowa pomoc

Ostatnia aktualizacja: 2026-02-21
Testowano z: GroupDocs.Annotation 25.2 for Java
Autor: GroupDocs