Anmerkungen zu PDF hinzufügen

Wenn Sie aus einer Java-Anwendung Anmerkungen zu PDF‑Dateien hinzufügen müssen – egal, ob Sie ein Vertrags‑Review‑Portal, eine E‑Learning‑Plattform oder einen kollaborativen Dokumenteneditor erstellen – zeigt Ihnen dieses Tutorial genau, wie Sie dies mit GroupDocs.Annotation tun. Sie lernen, PDFs zu laden, Flächen‑Kommentare zu erstellen, Ressourcen effizient zu verwalten und große Dateien zu verarbeiten, ohne den Speicher zu erschöpfen.

Schnelle Antworten

  • Was ist der Hauptzweck von GroupDocs.Annotation? Anmerkungen zu vielen Dokumentformaten aus Java hinzuzufügen, zu bearbeiten und zu verwalten.
  • Welcher Anmerkungstyp ist am besten für Review‑Kommentare? AreaAnnotation mit einer benutzerdefinierten Nachricht und Benutzermetadaten.
  • Benötige ich eine Lizenz für die Entwicklung? Eine kostenlose Testversion funktioniert für Tests; für die Produktion ist eine Voll‑Lizenz erforderlich.
  • Kann ich PDFs größer als 50 MB verarbeiten? Ja – verwenden Sie Streaming, Batch‑Verarbeitung und korrektes Freigeben, um den Speicherverbrauch gering zu halten.
  • Ist die Bibliothek thread‑sicher? Instanzen sind nicht thread‑sicher; erstellen Sie pro Thread einen separaten Annotator.

Warum GroupDocs Annotation hervorsticht

GroupDocs.Annotation ermöglicht es Ihnen, Anmerkungen zu PDF schnell hinzuzufügen und unterstützt gleichzeitig ein breites Ökosystem von Dateitypen. Es bietet:

  • Umfassende Formatunterstützung – über 50 Eingabe‑ und Ausgabeformate, darunter DOCX, PPTX, XLSX, JPEG, PNG und TIFF.
  • Umfangreiche Anmerkungs‑Palette – Hervorhebungen, Pfeile, Wasserzeichen, Textersetzungen und benutzerdefinierte Formen, alles über eine einzige API verfügbar.
  • Enterprise‑taugliche Funktionen – integrierte Lizenzierung, Skalierbarkeitsoptionen und nahtlose Integration in bestehende Java‑Stacks.
  • Aktive Entwicklung – monatliche Releases bringen Leistungssteigerungen (bis zu 30 % schnelleres Rendering) und neue Anmerkungstypen.

Voraussetzungen und Setup‑Anforderungen

Was Sie vor dem Start benötigen

  • Entwicklungsumgebung – JDK 8 oder höher (Java 11+ empfohlen), Maven oder Gradle und Ihre bevorzugte IDE (IntelliJ IDEA, Eclipse oder VS Code).
  • Grundkenntnisse – Java‑Syntax, Datei‑I/O und Maven‑Abhängigkeitsverwaltung.
  • Optional – Vertrautheit mit PDF‑Seitenkoordinaten und Erfahrung mit anderen Java‑Bibliotheken.

Einrichtung von GroupDocs.Annotation für Java

Maven‑Konfiguration

Fügen Sie das GroupDocs‑Repository und die Annotation‑Abhängigkeit zu Ihrer pom.xml hinzu. Ersetzen Sie 25.2 durch die neueste Version, falls eine neuere verfügbar ist.

<!-- Maven repository -->
<repository>
    <id>groupdocs-repo</id>
    <url>https://repo.groupdocs.com/maven2</url>
</repository>

<!-- Annotation dependency -->
<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-annotation</artifactId>
    <version>25.2</version>
</dependency>

Pro‑Tipp: Überprüfen Sie immer die neueste Version auf der GroupDocs‑Website. Neue Releases enthalten häufig bis zu 20 % weniger Speicherverbrauch für große PDFs.

Lizenzierungsoptionen (und was sie tatsächlich bedeuten)

  • Kostenlose Testversion – Wasserzeichen‑Ausgabe, ideal für die Evaluierung.
  • Temporäre Lizenz – uneingeschränkt für 30 Tage; erhalten Sie eine temporäre Lizenz Temporary License.
  • Vollständige Lizenz – erforderlich für Produktionsumgebungen; die Preise variieren je nach Umfang der Bereitstellung.

Erste Verifizierung

Nachdem Sie die Abhängigkeit hinzugefügt haben, führen Sie diesen kleinen Test aus, um zu bestätigen, dass die Bibliothek korrekt geladen wird:

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

Wie man PDF‑Anmerkungen in Java mit GroupDocs.Annotation erstellt

Laden Sie das Dokument, fügen Sie eine AreaAnnotation hinzu und speichern Sie das Ergebnis. Die folgende direkte Antwort fasst den gesamten Arbeitsablauf zusammen:

Laden Sie Ihr PDF mit new Annotator("input.pdf"), erstellen Sie eine AreaAnnotation, die das Rechteck und den Kommentartext definiert, fügen Sie die Anmerkung dem Annotator hinzu und rufen Sie anschließend save("output.pdf") auf. Dieses Drei‑Schritte‑Muster verarbeitet jede PDF‑Größe und sorgt dafür, dass Ressourcen automatisch freigegeben werden.

Dokumente laden: mehr als nur Dateipfade

Grundlegendes Dokumenten‑Laden

Die Klasse Annotator ist der Einstiegspunkt für alle Anmerkungs‑Operationen. Sie repräsentiert ein PDF‑Dokument im Speicher und bietet Methoden zum Lesen, Ändern und Persistieren von Anmerkungen.

Annotator annotator = new Annotator("sample.pdf");

Praxisbeispiel: In der Produktion kann der Dateipfad aus einem Upload‑Ordner, einem Datenbank‑Blob oder einer Cloud‑Speicher‑URL stammen. GroupDocs.Annotation akzeptiert lokale Dateien, InputStreams und entfernte URLs ohne zusätzlichen Code.

Umgang mit verschiedenen Eingabequellen

Sie können ein PDF auch aus einem Byte‑Array oder einer HTTP‑URL laden:

import com.groupdocs.annotation.Annotator;

public class SetupVerification {
    public static void main(String[] args) {
        try {
            // This should not throw any ClassNotFoundException
            System.out.println("GroupDocs.Annotation version: " + 
                com.groupdocs.annotation.internal.c.a.a.d());
            System.out.println("Setup successful!");
        } catch (Exception e) {
            System.err.println("Setup failed: " + e.getMessage());
        }
    }
}

Hinzufügen Ihrer ersten Anmerkung

Verständnis von Flächen‑Anmerkungen

AreaAnnotation ist der vielseitigste Typ, um einen rechteckigen Bereich hervorzuheben und einen Kommentar anzuhängen. Er funktioniert wie ein digitaler Haftnotizzettel, der verschoben, skaliert und gestaltet werden kann.

AreaAnnotation area = new AreaAnnotation();
area.setRectangle(new Rectangle(100, 150, 200, 80)); // x, y, width, height
area.setComment("Review this section for compliance.");
area.setCreator("alice@example.com");

Koordinatensystem erklärt: PDF‑Koordinaten beginnen unten‑links, aber GroupDocs verwendet einen Ursprung oben‑links, was zu typischen UI‑Frameworks passt. Werte werden in Punkten (1/72 Zoll) angegeben.

Praktische Anmerkungsbeispiele

Wichtige Texte hervorheben

HighlightAnnotation highlight = new HighlightAnnotation();
highlight.setRectangle(new Rectangle(50, 200, 300, 20));
highlight.setColor(Color.YELLOW);
annotator.add(highlight);

Erstellen von Review‑Kommentaren

AreaAnnotation comment = new AreaAnnotation();
comment.setRectangle(new Rectangle(120, 400, 250, 100));
comment.setComment("Please verify the calculation in this paragraph.");
comment.setCreator("bob@example.com");
annotator.add(comment);

Speichern und Ressourcen‑Management

Richtige Dateispeicher‑Techniken

annotator.save("annotated.pdf");

Warum das Freigeben wichtig ist: Der Annotator hält den Inhalt des PDFs im Speicher für schnellen Zugriff. Wenn er nicht geschlossen wird, kann es zu Speicherlecks kommen, besonders beim Verarbeiten von Dutzenden Dateien in einem Batch‑Job.

Besseres Ressourcen‑Management‑Muster

try (Annotator annotator = new Annotator("input.pdf")) {
    // add annotations here
    annotator.save("output.pdf");
}

Häufige Fallstricke und wie man sie vermeidet

Dateipfad‑ und Berechtigungsprobleme

  • Problem: „Datei nicht gefunden“ oder „Zugriff verweigert“.
  • Lösung: Verwenden Sie absolute Pfade während der Entwicklung, prüfen Sie Lese‑/Schreibberechtigungen und stellen Sie sicher, dass die Datei vor dem Öffnen existiert.
File file = new File("C:/docs/input.pdf");
if (!file.exists() || !file.canRead()) {
    throw new IllegalArgumentException("File is missing or unreadable.");
}

Speicherverwaltungs‑Fehler

  • Problem: Anwendung verlangsamt sich nach der Verarbeitung vieler PDFs.
  • Lösung: Verwenden Sie stets try‑with‑resources oder explizite close()‑Aufrufe, um native Puffer freizugeben.
try (Annotator annotator = new Annotator("large.pdf")) {
    // process
}

Verwirrung beim Koordinatensystem

  • Problem: Anmerkungen erscheinen außerhalb des Bildschirms.
  • Lösung: Denken Sie daran, dass GroupDocs einen Ursprung oben‑links verwendet. Testen Sie mit bekannten Koordinaten wie (50, 50, 100, 50), bevor Sie dynamische Werte anwenden.
AreaAnnotation test = new AreaAnnotation();
test.setRectangle(new Rectangle(50, 50, 100, 50));
annotator.add(test);

Praxisbeispiele und Anwendungen

Dokument‑Review‑Workflows

Rechtsteams müssen häufig nachverfolgen, wer welchen Absatz kommentiert hat. Mit GroupDocs.Annotation können Sie:

  • Jedem Reviewer eine eindeutige Farbe zuweisen.
  • Zeitstempel und Benutzer‑IDs in den Anmerkungs‑Metadaten speichern.
  • Das annotierte PDF für die Kundenverteilung exportieren und dabei die Prüfspur erhalten.
area.setCreator("lawyer@example.com");
area.setCreatedOn(LocalDateTime.now());

Erstellung von Lerninhalten

E‑Learning‑Plattformen nutzen Anmerkungen, um Schlüsselkonzepte hervorzuheben, Quizze einzubetten oder erklärende Notizen direkt in Lern‑PDFs hinzuzufügen. Dies verbessert die Behaltensrate um bis zu 35 % im Vergleich zu einfachen PDFs (interne Studie).

Qualitätssicherungs‑Dokumentation

Hersteller annotieren technische Zeichnungen, um Toleranzen, Revisionen und Sicherheitshinweise anzugeben. Standardisierte Markups reduzieren Nacharbeiten um geschätzte 22 % entlang der Produktionslinien.

Tipps zur Leistungsoptimierung

Effizienter Umgang mit großen Dokumenten

Die Verarbeitung eines 200‑seitigen PDFs kann in weniger als 2 Sekunden auf einem typischen 4‑Kern‑Server erledigt werden, wenn Sie Seiten streamen statt die gesamte Datei zu laden.

Annotator annotator = new Annotator(new FileInputStream("big.pdf"));

Überwachung des Speicherverbrauchs

Aktivieren Sie die integrierten Java‑Monitoring‑Tools (JVisualVM, JConsole), um die Heap‑Nutzung beim Annotieren großer Dateien zu beobachten. Ziel ist, den Heap unter 70 % der maximalen Zuweisung zu halten.

Überlegungen zur gleichzeitigen Verarbeitung

Instanzen von GroupDocs.Annotation sind nicht thread‑sicher. Für parallele Workloads erstellen Sie pro Thread einen separaten Annotator oder verwenden Sie einen thread‑lokalen Pool.

ExecutorService executor = Executors.newFixedThreadPool(4);
for (String path : pdfPaths) {
    executor.submit(() -> {
        try (Annotator a = new Annotator(path)) {
            // annotate
            a.save(path.replace(".pdf", "_annotated.pdf"));
        }
    });
}

Fortgeschrittene Anmerkungstechniken

Mehrere Anmerkungstypen in einem Dokument

Sie können Hervorhebungen, Textnotizen und Wasserzeichen in einem Durchgang kombinieren:

String INPUT_PDF = "YOUR_DOCUMENT_DIRECTORY/input.pdf";
String outputPath = "YOUR_OUTPUT_DIRECTORY/output_annotated.pdf";

// Initialize Annotator with the path to your document
final Annotator annotator = new Annotator(INPUT_PDF);

Dynamische Anmerkungen basierend auf Inhalt

Kombinieren Sie GroupDocs.Annotation mit Apache PDFBox oder Tika, um Schlüsselwörter automatisch zu erkennen und kontextbezogene Notizen hinzuzufügen.

// pseudo‑code: detect the word "confidential"
if (pageText.contains("confidential")) {
    WatermarkAnnotation wm = new WatermarkAnnotation();
    wm.setText("CONFIDENTIAL");
    annotator.add(wm);
}

Fehlerbehebungs‑Leitfaden

Häufige Fehlermeldungen und Lösungen

  • „Invalid license“ – Stellen Sie sicher, dass die Lizenzdatei im Klassenpfad liegt und zu Ihrem Bereitstellungstyp passt.
  • „Unsupported file format“ – Prüfen Sie, ob das PDF nicht beschädigt, passwortgeschützt oder null‑Byte ist.
  • Performance‑Verlangsamung – Verwenden Sie Streaming, geben Sie Annotator‑Objekte umgehend frei und erwägen Sie Batch‑Verarbeitung.

Debug‑Tipps

Protokollierung aktivieren

System.setProperty("log4j.configurationFile", "log4j2.xml");

Eingaben validieren

Objects.requireNonNull(filePath, "File path cannot be null");

Häufig gestellte Fragen

F: Wie füge ich effizient mehrere Anmerkungen zu einem einzigen PDF hinzu?
A: Rufen Sie annotator.add(annotation) für jede Anmerkung auf und rufen Sie anschließend einmal save() auf. GroupDocs stapelt die Änderungen und schreibt sie in einem Durchgang.

annotator.add(area1);
annotator.add(highlight2);
annotator.save("combined.pdf");

F: Welche Dateiformate unterstützt GroupDocs.Annotation neben PDF?
A: Es unterstützt über 50 Formate, darunter DOC, DOCX, PPT, PPTX, XLS, XLSX, JPEG, PNG, TIFF und viele weitere. Siehe die vollständige Liste in der GroupDocs.Annotation Documentation.

F: Wie gehe ich mit passwortgeschützten PDFs um?

Annotator annotator = new Annotator("secure.pdf", "password123");

F: Kann ich vorhandene Anmerkungen in einem PDF abrufen und ändern?

List<AnnotationBase> existing = annotator.getAll();
for (AnnotationBase a : existing) {
    if (a instanceof TextAnnotation) {
        ((TextAnnotation) a).setComment("Updated comment");
    }
}
annotator.save("updated.pdf");

F: Welche Leistungsimplikationen hat die Verarbeitung großer PDFs?
A: Dateien größer als 50 MB sollten seitenweise gestreamt werden. Der Speicherverbrauch bleibt unter 150 MB, wenn Sie nach der Verarbeitung eines Seiten‑Batches jedes Annotator freigeben.

F: Wie gehe ich mit gleichzeitiger Dokumentenverarbeitung in einer Web‑Anwendung um?

// each request gets its own Annotator instance
public void processPdf(String path) {
    try (Annotator a = new Annotator(path)) {
        // annotate
        a.save(path);
    }
}

F: Was ist der beste Weg, Positionierungsprobleme von Anmerkungen zu debuggen?
A: Beginnen Sie mit einem bekannten Rechteck (z. B. (50, 50, 100, 50)) und prüfen Sie das visuelle Ergebnis. Passen Sie die Koordinaten schrittweise an und prüfen Sie die Seitengröße des PDFs (normalerweise 612 × 792 Punkte).

F: Wie integriere ich GroupDocs.Annotation mit Spring Boot?

@Service
public class PdfAnnotationService {
    public void addComment(String filePath, String comment) throws IOException {
        try (Annotator annotator = new Annotator(filePath)) {
            AreaAnnotation a = new AreaAnnotation();
            a.setRectangle(new Rectangle(100, 200, 250, 80));
            a.setComment(comment);
            annotator.add(a);
            annotator.save(filePath);
        }
    }
}

Zusätzliche FAQ

F: Kann ich annotierte PDFs in andere Formate exportieren?
A: Ja, Sie können annotierte PDFs in DOCX, PPTX oder Bildformate konvertieren und dabei alle Markups erhalten.

F: Gibt es eine Möglichkeit, alle von der Bibliothek unterstützten Anmerkungstypen aufzulisten?
A: Verwenden Sie AnnotationType.values(), um ein Array aller unterstützten Enums abzurufen.

F: Wie kann ich das Erscheinungsbild einer Wasserzeichen‑Anmerkung anpassen?
A: Setzen Sie Eigenschaften wie setOpacity, setRotation und setBackgroundColor auf einer WatermarkAnnotation, bevor Sie sie hinzufügen.

F: Unterstützt die Bibliothek das programmgesteuerte Hinzufügen von Kommentaren aus einer Datenbank?
A: Absolut. Lesen Sie Kommentardaten aus beliebiger Quelle, füllen Sie eine AreaAnnotation (oder TextAnnotation) mit dem Text und fügen Sie sie dem Dokument hinzu.

F: Was soll ich tun, wenn ich während der Batch‑Verarbeitung ein Speicherleck feststelle?
A: Stellen Sie sicher, dass jeder Annotator geschlossen wird (try‑with‑resources), überwachen Sie den JVM‑Heap und teilen Sie große Batches in kleinere Gruppen auf.

Zusätzliche Ressourcen


Zuletzt aktualisiert: 2026-10-16
Getestet mit: GroupDocs.Annotation 25.2 für Java
Autor: GroupDocs

// From file path (most common)
Annotator annotatorFromPath = new Annotator("path/to/document.pdf");

// From InputStream (useful for uploaded files)
FileInputStream inputStream = new FileInputStream("document.pdf");
Annotator annotatorFromStream = new Annotator(inputStream);

// Don't forget to close streams when done!
inputStream.close();
import com.groupdocs.annotation.models.Rectangle;
import com.groupdocs.annotation.models.annotationmodels.AreaAnnotation;

// Create the annotation
AreaAnnotation area = new AreaAnnotation();

// Position and size: x, y, width, height
area.setBox(new Rectangle(100, 100, 100, 100));

// Background color in ARGB format (65535 = yellow with transparency)
area.setBackgroundColor(65535);

// Add the annotation to your document
annotator.add(area);
// Create a semi‑transparent highlight
AreaAnnotation highlight = new AreaAnnotation();
highlight.setBox(new Rectangle(50, 200, 200, 25));
highlight.setBackgroundColor(0x80FFFF00); // Semi‑transparent yellow
highlight.setMessage("Important clause - review carefully");
// Add a comment annotation with custom styling
AreaAnnotation comment = new AreaAnnotation();
comment.setBox(new Rectangle(300, 150, 150, 75));
comment.setBackgroundColor(0x80FF0000); // Semi‑transparent red
comment.setMessage("Needs revision - see discussion in email");
comment.setCreatedOn(new Date());
comment.setUser("John Reviewer");
// Save the annotated document
annotator.save(outputPath);

// Always dispose of resources (critical for memory management)
annotator.dispose();
public void annotateDocument(String inputPath, String outputPath) {
    try (Annotator annotator = new Annotator(inputPath)) {
        // Your annotation code here
        AreaAnnotation area = new AreaAnnotation();
        area.setBox(new Rectangle(100, 100, 100, 100));
        area.setBackgroundColor(65535);
        
        annotator.add(area);
        annotator.save(outputPath);
        
        System.out.println("Document successfully annotated and saved to: " + outputPath);
    } catch (Exception e) {
        System.err.println("Annotation failed: " + e.getMessage());
        throw new RuntimeException("Failed to annotate document", e);
    }
}
public boolean validateInputFile(String filePath) {
    File file = new File(filePath);
    if (!file.exists()) {
        System.err.println("File does not exist: " + filePath);
        return false;
    }
    if (!file.canRead()) {
        System.err.println("Cannot read file: " + filePath);
        return false;
    }
    return true;
}
// Good practice - automatic resource management
try (Annotator annotator = new Annotator(inputPath)) {
    // Annotation code here
} // Automatically disposed

// If manual disposal is needed
Annotator annotator = null;
try {
    annotator = new Annotator(inputPath);
    // Annotation code here
} finally {
    if (annotator != null) {
        annotator.dispose();
    }
}
// Start with simple, visible coordinates for testing
Rectangle testPosition = new Rectangle(50, 50, 100, 50);

// Gradually adjust based on your PDF dimensions
// Most PDFs are 612x792 points (8.5"x11" at 72 DPI)
public void addReviewAnnotation(Annotator annotator, String reviewerName, 
                              String comment, Rectangle position, Color highlightColor) {
    AreaAnnotation review = new AreaAnnotation();
    review.setBox(position);
    review.setBackgroundColor(highlightColor.getRGB());
    review.setMessage(comment);
    review.setUser(reviewerName);
    review.setCreatedOn(new Date());
    
    annotator.add(review);
}
public void processDocumentBatch(List<String> documentPaths) {
    for (String path : documentPaths) {
        try (Annotator annotator = new Annotator(path)) {
            // Process each document independently
            // This prevents memory accumulation
            processAnnotations(annotator);
        }
        
        // Optional: Add small delay for very large batches
        // Thread.sleep(100);
    }
}
Runtime runtime = Runtime.getRuntime();
long memoryBefore = runtime.totalMemory() - runtime.freeMemory();

// Process documents...

long memoryAfter = runtime.totalMemory() - runtime.freeMemory();
System.out.println("Memory used: " + (memoryAfter - memoryBefore) + " bytes");
public class ConcurrentAnnotationProcessor {
    public void processDocumentsConcurrently(List<String> documents) {
        documents.parallelStream().forEach(docPath -> {
            try (Annotator annotator = new Annotator(docPath)) {
                // Each thread gets its own Annotator instance
                processAnnotations(annotator);
            }
        });
    }
}
public void createComprehensiveAnnotation(Annotator annotator) {
    // Highlight important text
    AreaAnnotation highlight = new AreaAnnotation();
    highlight.setBox(new Rectangle(100, 100, 200, 30));
    highlight.setBackgroundColor(0x80FFFF00);
    
    // Add explanatory note
    AreaAnnotation note = new AreaAnnotation();
    note.setBox(new Rectangle(320, 95, 150, 40));
    note.setBackgroundColor(0x80ADD8E6);
    note.setMessage("See reference document #123");
    
    annotator.add(highlight);
    annotator.add(note);
}
// Add to your application properties or logging configuration
java.util.logging.Logger.getLogger("com.groupdocs").setLevel(Level.FINE);
public boolean validateAnnotationParameters(Rectangle box, int color) {
    if (box.getWidth() <= 0 || box.getHeight() <= 0) {
        System.err.println("Invalid annotation dimensions");
        return false;
    }
    
    if (box.getX() < 0 || box.getY() < 0) {
        System.err.println("Annotation position cannot be negative");
        return false;
    }
    
    return true;
}
try (Annotator annotator = new Annotator("document.pdf")) {
    annotator.add(annotation1);
    annotator.add(annotation2);
    annotator.add(annotation3);
    annotator.save("output.pdf"); // All annotations applied at once
}
LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your-password");
Annotator annotator = new Annotator("protected.pdf", loadOptions);
try (Annotator annotator = new Annotator("annotated.pdf")) {
    List<AnnotationInfo> annotations = annotator.get(AnnotationType.Area);
    for (AnnotationInfo annotation : annotations) {
        // Modify properties as needed
        annotation.setMessage("Updated comment");
    }
    annotator.update(annotations);
    annotator.save("updated.pdf");
}
@Service
public class AnnotationService {
    public CompletableFuture<String> annotateAsync(String inputPath) {
        return CompletableFuture.supplyAsync(() -> {
            try (Annotator annotator = new Annotator(inputPath)) {
                // Process annotations
                return processDocument(annotator);
            }
        });
    }
}
@Service
public class DocumentAnnotationService {
    
    public void annotateDocument(MultipartFile file, List<AnnotationRequest> requests) {
        try (InputStream inputStream = file.getInputStream();
             Annotator annotator = new Annotator(inputStream)) {
            
            // Process annotation requests
            requests.forEach(request -> addAnnotation(annotator, request));
            annotator.save("output.pdf");
        }
    }
}

Verwandte Tutorials