Java PDF Annotationsbibliothek: Annotation‑Antwort erstellen in Java

Wenn Sie create annotation reply java für PDFs benötigen—egal, ob Sie ein Vertrags‑Review‑Portal, ein E‑Learning‑System oder eine Batch‑Verarbeitungspipeline erstellen—zeigt Ihnen dieser Leitfaden genau, wie Sie dies mit GroupDocs.Annotation für Java umsetzen. Wir gehen die Einrichtung, das Erstellen von squiggly‑Annotations, das Threaden von Antworten und die Leistungsoptimierung durch, damit Sie in Tagen, nicht Wochen, eine zuverlässige Lösung bereitstellen können.

Schnelle Antworten

  • Was ist der Hauptzweck von GroupDocs.Annotation? Es ermöglicht die programmgesteuerte Erstellung, Änderung und Extraktion von PDF‑Annotationen in Java.
  • Wie füge ich eine squiggly‑Annotation hinzu? Instanziieren Sie SquigglyAnnotation, setzen Sie deren Geometrie und Stil und rufen Sie dann annotator.add(...) auf.
  • Kann ich einer Annotation Antworten anhängen? Ja—erstellen Sie Reply‑Objekte, setzen Sie Autor und Text und verknüpfen Sie sie mit der übergeordneten Annotation.
  • Benötige ich eine Lizenz für die Produktion? Absolut; ohne eine gültige Lizenz enthält die Ausgabe Wasserzeichen.
  • Ist es für die Batch‑Verarbeitung geeignet? Ja—verwenden Sie try‑with‑resources, um jedes Dokument zu öffnen, zu annotieren und zu schließen, wodurch der Speicherverbrauch gering bleibt.

Warum Java‑Entwickler PDF‑Annotationsbibliotheken benötigen

Das manuelle Markieren von PDFs ist zeitaufwendig und fehleranfällig, besonders wenn Sie Hunderte von Verträgen oder Prüfungsunterlagen prüfen müssen. Eine Java‑PDF‑Annotationsbibliothek automatisiert diese Arbeit, sodass Sie Hervorhebungen, squiggly‑Unterstreichungen und Thread‑Kommentare direkt in die Datei einbetten können. Das Ergebnis ist ein durchsuchbares, portables Dokument, das alle Markierungen beibehält, ohne dass ein separater Viewer erforderlich ist.

Was Sie in diesem Leitfaden beherrschen werden

  • Installation und Lizenzierung von GroupDocs.Annotation in einem Maven‑Projekt
  • Erstellung von squiggly‑Annotationen, die wie native Word‑Unterstreichungen aussehen
  • Hinzufügen von Thread‑Antworten zu jeder Annotation für kollaborative Überprüfungen
  • Optimierung von Speicher- und CPU‑Verbrauch beim Verarbeiten großer PDFs
  • Bereitstellung der Lösung in Spring Boot, Micro‑Services oder Desktop‑Apps

Egal, ob Sie ein System zur rechtlichen Dokumentenprüfung, ein Bildungs‑Bewertungstool oder eine automatisierte Qualitätskontroll‑Pipeline erstellen, die nachstehenden Techniken bieten Ihnen eine produktionsreife Grundlage.

Was ist create annotation reply java?

create annotation reply java ist der programmgesteuerte Prozess, einen Kommentar‑Thread (eine Reply) an einer bestehenden PDF‑Annotation mit Java anzuhängen. Antworten ermöglichen es mehreren Prüfern, eine bestimmte Markierung zu diskutieren, ohne das Dokument zu verlassen, und ermöglichen nahtlose, integrierte Zusammenarbeit. Diese Fähigkeit verwandelt ein statisches PDF in eine interaktive Diskussionsplattform, die Kontext und Prüfpfade direkt in der Datei bewahrt.

Voraussetzungen: Vorbereitung Ihrer Umgebung

Bevor wir in den Code eintauchen, prüfen Sie, ob Ihr Entwicklungsarbeitsplatz diese Anforderungen erfüllt:

  • JDK 8 oder höher (JDK 11 + wird für bessere Garbage‑Collection‑Leistung empfohlen)
  • Maven oder Gradle für das Abhängigkeitsmanagement (Beispiele verwenden Maven)
  • Eine IDE mit Maven‑Unterstützung (IntelliJ IDEA, Eclipse oder VS Code)
  • Mindestens 2 GB freien RAM für die IDE und Testläufe
  • Beispiel‑PDF‑Dateien zum Experimentieren (Sie können einfache PDFs mit jedem PDF‑Editor erzeugen)

GroupDocs.Annotation läuft vollständig im Prozess; keine externen PDF‑Viewer oder nativen Bibliotheken sind erforderlich.

Einrichtung von GroupDocs.Annotation für Java

Die Integration der Bibliothek ist ein mehrstufiger Prozess, aber einige versteckte Stolperfallen können Laufzeitfehler verursachen, wenn Sie sie übersehen.

Maven‑Abhängigkeitskonfiguration

Fügen Sie das Repository und die Abhängigkeit zu Ihrer pom.xml hinzu. Platzieren Sie das <repositories>‑Element vor <dependencies>, damit Maven das Artefakt auflösen kann.

<repositories>
    <repository>
        <id>groupdocs-repo</id>
        <url>https://repo.groupdocs.com/repo</url>
    </repository>
</repositories>

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

Pro Tipp: Überprüfen Sie die GroupDocs‑Releases‑Seite für die neueste Version. Neue Releases enthalten oft Unterstützung für neue PDF‑Standards und Leistungsverbesserungen.

Lizenzsetup (Nicht überspringen!)

GroupDocs.Annotation erfordert für die Produktion eine Lizenzdatei. Ohne diese trägt jedes erzeugte PDF ein Wasserzeichen.

  1. Kostenlose Testversion – Vollständiger Funktionsumfang für 30 Tage, ideal für die Evaluierung.
  2. Temporäre Lizenz – Gut für Entwicklung und interne Tests.
  3. Vollständige Lizenz – Erforderlich für jede kommerzielle Bereitstellung.

Legen Sie die Datei GroupDocs.Annotation.lic in Ihrem Ressourcen‑Ordner ab und laden Sie sie beim Start:

License license = new License();
license.setLicense("GroupDocs.Annotation.lic");

Häufiges Problem: Das Vergessen des Lizenzschritts führt zu PDFs mit Wasserzeichen und API‑Aufrufen, die stillschweigend fehlschlagen. Validieren Sie die Lizenz immer früh in Ihrer Start‑Routine.

Vollständige Implementierungsanleitung: Hinzufügen von Squiggly‑Annotationen

Nachfolgend finden Sie eine Schritt‑für‑Schritt‑Durchführung, die zeigt, wie Sie create annotation reply java erstellen, während Sie eine squiggly‑Annotation bauen. Jeder Schritt enthält eine knappe Erklärung, damit Sie das „Warum“ hinter jeder Zeile verstehen.

Schritt 1: Alle erforderlichen Klassen importieren

import com.groupdocs.annotation.Annotator;
import com.groupdocs.annotation.models.Point;
import com.groupdocs.annotation.models.annotation.SquigglyAnnotation;
import com.groupdocs.annotation.models.annotation.Reply;
import com.groupdocs.annotation.options.SaveOptions;
  • Annotator ist der Einstiegspunkt für alle dokumentbezogenen Vorgänge.
  • Point repräsentiert eine Koordinate auf einer Seite (X und Y gemessen vom oberen linken Rand).
  • SquigglyAnnotation definiert die wellige Unterstreichung, die zum Hervorheben von Fehlern verwendet wird.
  • Reply speichert Thread‑Kommentare, die an einer Annotation angehängt sind.
  • SaveOptions ermöglicht die Steuerung von Ausgabeformat und Kompression.

Schritt 2: Ihre Squiggly‑Annotation erstellen und konfigurieren

SquigglyAnnotation squiggly = new SquigglyAnnotation();
squiggly.setPageNumber(1);
squiggly.setColor(0xFFFF0000); // ARGB red
squiggly.setOpacity(0.7);
squiggly.setPoints(Arrays.asList(
    new Point(100, 200),
    new Point(300, 200)
));

SquigglyAnnotation ist eine Klasse, die eine wellige Unterstreichung erzeugt, die zum Hervorheben von Fehlern in einem PDF verwendet wird.

  • Koordinatensystem: Punkte beginnen in der oberen linken Ecke. Die beiden obigen Punkte zeichnen eine horizontale wellige Linie von (100, 200) nach (300, 200).
  • Opacity 0.7 bedeutet, dass die Annotation zu 70 % undurchsichtig ist, sodass der darunterliegende Text lesbar bleibt.

Schritt 3: Interaktive Antworten hinzufügen (optional aber leistungsstark)

Reply reply1 = new Reply();
reply1.setComment("Please double‑check this clause.");
reply1.setAuthor("Alice");
reply1.setCreatedOn(new Date());

Reply reply2 = new Reply();
reply2.setComment("I think the wording is correct.");
reply2.setAuthor("Bob");
reply2.setCreatedOn(new Date());

squiggly.setReplies(Arrays.asList(reply1, reply2));

Reply ist eine Klasse, die einen Kommentar‑Thread darstellt, der an einer Annotation angehängt ist.

  • Antworten erzeugen eine Thread‑Diskussion direkt auf der Annotation und spiegeln das Erlebnis moderner PDF‑Reviewer wider.
  • Jede Antwort speichert Autorinformationen und einen Zeitstempel, die Sie später filtern oder in einer UI anzeigen können.

Schritt 4: Annotation anwenden und Dokument speichern

try (Annotator annotator = new Annotator("input.pdf")) {
    annotator.add(squiggly);
    SaveOptions options = new SaveOptions();
    options.setOutputPath("output.pdf");
    annotator.save(options);
}
  • Der try‑with‑resources‑Konstrukt schließt automatisch den Annotator, gibt Dateihandles und native Puffer frei.
  • save schreibt das modifizierte PDF nach output.pdf.

Speicherhinweis: Der Annotator lädt nur die Seiten, die Sie berühren. Bei PDFs mit mehreren hundert Seiten hält dieser Ansatz die Heap‑Nutzung unter 150 MB auf einem typischen Server.

Erweiterte Konfigurationsoptionen

Anpassung des Aussehens von Annotationen

Sie können den visuellen Stil feinabstimmen, um Ihren Markenrichtlinien zu entsprechen:

squiggly.setBorderWidth(2);
squiggly.setColor(0xFF00FF00); // ARGB green
squiggly.setOpacity(0.5);
  • Border width steuert die Linienstärke (in Punkten).
  • ARGB‑Format enthält einen Alpha‑Kanal für Transparenz.

Präzises Positionieren von Annotationen

Die richtigen Koordinaten zu erhalten kann bei PDFs mit unterschiedlichen Seitengrößen knifflig sein. Folgen Sie diesem systematischen Ansatz:

  1. Öffnen Sie das PDF in einem Viewer (z. B. Adobe Acrobat) und notieren Sie die Linealwerte für den Zielbereich.
  2. Übersetzen Sie die Linealwerte in Punkte (1 Punkt = 1/72 Zoll).
  3. Verwenden Sie annotator.getPageInfo(pageIndex), um Seitenbreite und -höhe abzurufen, und berechnen Sie dann relative Positionen.

Häufige Probleme und Lösungen

Problem: Annotationen erscheinen nicht

Wahrscheinlichste Ursachen

  • Punkte liegen außerhalb der Seitenränder
  • Lizenz nicht geladen (Wasserzeichen verbirgt die Annotation)
  • Falsche Seitennummer (Seiten sind in der API nullbasiert)

Lösungs‑Checkliste

- Verify page dimensions with annotator.getPageInfo(pageIndex)
- Ensure all Point X/Y values are within [0, pageWidth] and [0, pageHeight]
- Confirm license file path and that license.setLicense() returns true
- Check that squiggly.setPageNumber(pageIndex) uses zero‑based indexing

Problem: Schlechte Leistung bei großen Dateien

Das Laden eines 500‑Seiten‑PDFs in den Speicher kann Ihren Service verlangsamen. Mildern Sie dies durch:

  • Eine Seite nach der anderen verarbeiten – Dokument öffnen, eine einzelne Seite annotieren, speichern und dann zur nächsten wechseln.
  • Streaming – verwenden Sie die Streaming‑API von Annotator, um das vollständige Dokument‑Puffern zu vermeiden.
  • Caching – speichern Sie häufig genutzte PDFs in einem schnellen Cache (z. B. Redis) und annotieren Sie die zwischengespeicherte Kopie.

Problem: Farbwerte funktionieren nicht

GroupDocs erwartet ARGB (Alpha, Rot, Grün, Blau) statt einfachem RGB. Ein ARGB‑Wert von 0xFFFF0000 bedeutet vollständig undurchsichtiges Rot. Wenn Sie 0xFF0000 angeben, interpretiert die Bibliothek ihn falsch, was zu einer schwarzen Annotation führt.

int argbRed = 0xFFFF0000; // Alpha=255, Red=255, Green=0, Blue=0
squiggly.setColor(argbRed);

Leistungs‑Best Practices

Speichermanagement

Beim Annotieren von Dutzenden PDFs in einem Batch‑Job sollten Sie jede Datei in einen eigenen try‑with‑resources‑Block einbetten:

for (String filePath : pdfList) {
    try (Annotator annotator = new Annotator(filePath)) {
        // add annotations
        annotator.save(new SaveOptions().setOutputPath(filePath.replace(".pdf", "_annotated.pdf")));
    }
}
  • Dieses Muster garantiert, dass native Puffer nach jeder Iteration freigegeben werden, wodurch OutOfMemoryError bei langlaufenden Prozessen vermieden wird.

Optimierung der Batch‑Verarbeitung

Für Hochdurchsatz‑Umgebungen sollten Sie parallele Streams in Kombination mit einem begrenzten Thread‑Pool in Betracht ziehen:

ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
pdfList.parallelStream().forEach(path -> executor.submit(() -> annotateDocument(path)));
executor.shutdown();
executor.awaitTermination(1, TimeUnit.HOURS);
  • Begrenzter Pool verhindert eine Explosion von Threads, während parallele Streams die CPU‑Kerne auslasten.

Dateigrößen‑Überlegungen

Große PDFs (> 100 MB) können die Leistung beeinträchtigen. Wenden Sie diese Strategien an:

  • Vorkomprimieren Sie das Quell‑PDF mit einem Tool wie Ghostscript vor der Annotation.
  • Nur benötigte Seiten annotieren – Seiten überspringen, die keine Markierung benötigen.
  • Aufteilen des Dokuments in logische Abschnitte (z. B. pro Kapitel) und jede Einheit unabhängig verarbeiten.

Anwendungen in der Praxis

Dokumenten‑Review‑Systeme

Rechtsfirmen müssen häufig problematische Klauseln kennzeichnen. Squiggly‑Annotationen kombiniert mit Thread‑Antworten ermöglichen es mehreren Anwälten, einen einzelnen Absatz zu diskutieren, ohne das PDF zu verlassen:

  • Lawyer A fügt unter einer Klausel ein rotes squiggly hinzu und schreibt „Mehrdeutige Formulierung“.
  • Lawyer B antwortet „Definition für ‚material breach‘ hinzufügen“.
  • Die gesamte Diskussion bleibt eingebettet, durchsuchbar und prüfbar.

Integration in bestehende Systeme

GroupDocs.Annotation funktioniert reibungslos mit beliebten Java‑Frameworks:

  • Spring Boot – stellen Sie einen REST‑Endpunkt /api/annotate bereit, der einen PDF‑Multipart‑Upload akzeptiert, Annotationen hinzufügt und das Ergebnis zurückstreamt.
  • JSF – binden Sie Annotations‑Aktionen an UI‑Komponenten für sofortige Markierungen in einer Web‑Ansicht.
  • Microservices – der kleine Footprint der Bibliothek (< 15 MB) ermöglicht die Containerisierung mit Docker und horizontale Skalierung.

Workflow‑Automatisierung

Kombinieren Sie Annotationen mit anderen GroupDocs‑Produkten (z. B. GroupDocs.Signature), um End‑zu‑End‑Pipelines zu erstellen:

1. Upload contract → 2. Auto‑apply squiggly for missing signatures → 3. Add reviewer replies → 4. Route to signing service.

Wann Squiggly‑Annotationen vs. Alternativen verwenden

AnwendungsfallEmpfohlene Annotation
Markieren von Rechtschreib‑ oder GrammatikfehlernSquiggly – visueller Hinweis ähnlich wie in Textverarbeitungsprogrammen
Hervorheben wichtiger Abschnitte ohne einen Fehler anzudeutenHighlight – transparente Überlagerung
Detailliertes Feedback gebenText oder Comment – freiform Notizfeld
Genehmigen oder Ablehnen eines DokumentsStamp – „Approved“‑ oder „Rejected“‑Abzeichen

Fazit

Sie haben nun ein vollständiges, produktionsreifes Rezept für create annotation reply java mit GroupDocs.Annotation. Durch das Beherrschen der API, das Handling der Lizenzierung und die Anwendung der oben genannten Leistungstipps können Sie:

  • Fehlerkennzeichnung über tausende PDFs automatisieren
  • Kollaborative, Thread‑Diskussionen direkt in der Datei ermöglichen
  • Den Speicherverbrauch niedrig halten, selbst bei der Verarbeitung riesiger Dokumente

Nächste Schritte

  1. Mit anderen Annotationstypen experimentieren (Highlights, Stamps, Text).
  2. Einen REST‑Service erstellen, der PDFs empfängt, annotiert und das Ergebnis zurückgibt.
  3. Die Extraktions‑API (annotator.get()) erkunden, um vorhandene Kommentare für Analysen zu extrahieren.

Die Stärke der programmgesteuerten PDF‑Annotation liegt in ihrer Fähigkeit, mühsame manuelle Markierungen durch wiederholbaren, prüfbaren Code zu ersetzen. Egal, ob Sie ein Nischen‑Legal‑Tech‑Produkt oder eine universelle Dokument‑Workflow‑Engine bauen, die Techniken in diesem Leitfaden geben Ihnen ein solides Fundament für die weitere Entwicklung.

Häufig gestellte Fragen

Q: Was macht GroupDocs.Annotation besser als andere Java‑PDF‑Bibliotheken?
A: GroupDocs.Annotation konzentriert sich ausschließlich auf Annotation‑Workflows und bietet über 30 Annotationstypen, Thread‑Antworten und native Unterstützung für mehr als 50 Dateiformate, während der Speicherverbrauch bei PDFs mit 500 Seiten unter 200 MB bleibt.

Q: Kann ich diese Bibliothek mit Spring‑Boot‑Anwendungen verwenden?
A: Absolut. Erstellen Sie einen @RestController, der den Annotator‑Service injiziert, Multipart‑Uploads verarbeitet und das annotierte PDF zurück an den Client streamt. Denken Sie daran, einen Thread‑Pool für gleichzeitige Anfragen zu konfigurieren.

Q: Wie gehe ich mit Dokumenten unterschiedlicher Seitengrößen um?
A: Erfragen Sie die Abmessungen jeder Seite über annotator.getPageInfo(pageIndex) und berechnen Sie relative Koordinaten (z. B. Prozentsätze) anstelle von fest codierten Punktwerten. So erscheinen Annotationen korrekt auf A4-, Letter‑ und benutzerdefinierten Seiten.

Q: Gibt es eine Möglichkeit, vorhandene Annotationen aus PDFs zu extrahieren?
A: Ja. Rufen Sie annotator.get() auf, um eine Sammlung aller Annotationen zu erhalten, und iterieren Sie, um Eigenschaften wie Autor, Kommentar und Geometrie zu lesen. Dies ist nützlich für Migrations‑ oder Analyse‑Szenarien.

Q: Was ist der beste Ansatz für die Handhabung von Annotations‑Berechtigungen in Mehrbenutzer‑Systemen?
A: Implementieren Sie Authentifizierung auf Anwendungsebene, speichern Sie die Benutzer‑ID mit jedem Reply und setzen Sie Geschäftsregeln durch (z. B. kann nur der Autor oder ein Administrator eine Antwort bearbeiten oder löschen). Die API selbst erzwingt keine Berechtigungen und bietet Ihnen volle Flexibilität.

Q: Wie optimiere ich den Speicherverbrauch beim Verarbeiten von Hunderten PDFs?
A: Verwenden Sie try‑with‑resources für jedes Dokument, verarbeiten Sie Seiten einzeln und erwägen Sie einen begrenzten Thread‑Pool, um den gleichzeitigen Speicherverbrauch zu begrenzen. Die Überwachung des JVM‑Heaps mit Tools wie VisualVM hilft Ihnen, die -Xmx‑Einstellung fein abzustimmen.

Last Updated: 2026-05-16
Tested With: GroupDocs.Annotation 25.2 for Java
Author: GroupDocs

Additional Resources

{< /blocks/products/pf/tutorial-page-section >} {< /blocks/products/pf/main-container >} {< /blocks/products/pf/main-wrap-class >} {< blocks/products/products-backtop-button >}

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

import com.groupdocs.annotation.Annotator;

// Initialize your annotator - this is your entry point to all annotation features
try (Annotator annotator = new Annotator("path/to/your/document.pdf")) {
    // All your annotation magic happens here
    System.out.println("Annotator initialized successfully!");
}

import com.groupdocs.annotation.Annotator;
import com.groupdocs.annotation.models.Point;
import com.groupdocs.annotation.models.Reply;
import com.groupdocs.annotation.models.annotationmodels.SquigglyAnnotation;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

// Create a new SquigglyAnnotation instance
SquigglyAnnotation squigglyAnnotation = new SquigglyAnnotation();

// Set the creation date of the annotation
squigglyAnnotation.setCreatedOn(new Date());

// Define font and background colors using RGB values
squigglyAnnotation.setFontColor(65535); // Yellow color in ARGB format
squigglyAnnotation.setBackgroundColor(16761035); // Light blue color in ARGB format

// Set a message to display with the annotation
squigglyAnnotation.setMessage("This is squiggly annotation");

// Define opacity (range 0.0 - 1.0)
squigglyAnnotation.setOpacity(0.7);

// Specify the page number for the annotation (zero-based index)
squigglyAnnotation.setPageNumber(0);

// Set squiggly line color specific to Word and PDF documents
squigglyAnnotation.setSquigglyColor(1422623); // Color code for squiggly lines

// Define points marking the start and end of the annotation on the page
List<Point> points = new ArrayList<>();
points.add(new Point(80, 730));
points.add(new Point(240, 730));
points.add(new Point(80, 650));
points.add(new Point(240, 650));
squigglyAnnotation.setPoints(points);

// Create replies to the annotation (optional)
Reply reply1 = new Reply();
reply1.setComment("First comment");
reply1.setRepliedOn(new Date());

Reply reply2 = new Reply();
reply2.setComment("Second comment");
reply2.setRepliedOn(new Date());

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

// Associate replies with the annotation
squigglyAnnotation.setReplies(replies);

try (Annotator annotator = new Annotator("YOUR_DOCUMENT_DIRECTORY/input.pdf")) {
    // Add the prepared squiggly annotation to the document
    annotator.add(squigglyAnnotation);
    
    // Save the annotated document
    annotator.save("YOUR_OUTPUT_DIRECTORY/result_squiggly_annotation.pdf");
}

// Custom color configurations
squigglyAnnotation.setFontColor(0xFF0000); // Red text
squigglyAnnotation.setBackgroundColor(0x00FF00); // Green background
squigglyAnnotation.setSquigglyColor(0x0000FF); // Blue squiggly line

// Transparency effects
squigglyAnnotation.setOpacity(0.3); // Very subtle
// or
squigglyAnnotation.setOpacity(0.9); // Almost opaque

// Verify your points are within page boundaries
System.out.println("Page dimensions: " + annotator.getPageInfo(0));

// Check if your points make sense
List<Point> points = squigglyAnnotation.getPoints();
for (Point point : points) {
    System.out.println("Point: (" + point.getX() + ", " + point.getY() + ")");
}

// Wrong: RGB format
int wrongColor = 0xFF0000; // This might not work as expected

// Right: ARGB format
int rightColor = 0xFFFF0000; // Full opacity red

// Good practice: Use try-with-resources
try (Annotator annotator = new Annotator(inputPath)) {
    // Process annotations
    annotator.add(annotation);
    annotator.save(outputPath);
} // Automatic cleanup happens here

// Avoid: Manual resource management
Annotator annotator = new Annotator(inputPath); // Resources might leak

public void processBatch(List<String> documentPaths) {
    for (String path : documentPaths) {
        try (Annotator annotator = new Annotator(path)) {
            // Process each document independently
            addAnnotations(annotator);
            annotator.save(getOutputPath(path));
        } catch (Exception e) {
            // Handle individual document failures without stopping the batch
            System.err.println("Failed to process: " + path + " - " + e.getMessage());
        }
    }
}

public class DocumentWorkflow {
    public void reviewDocument(String documentPath, ReviewLevel level) {
        try (Annotator annotator = new Annotator(documentPath)) {
            switch (level) {
                case GRAMMAR_CHECK:
                    addGrammarAnnotations(annotator);
                    break;
                case LEGAL_REVIEW:
                    addLegalAnnotations(annotator);
                    break;
                case FINAL_PROOF:
                    addProofreadingAnnotations(annotator);
                    break;
            }
            annotator.save(getReviewedPath(documentPath));
        }
    }
}

Verwandte Tutorials