Java PDF Annotation Library: annotáció válasz létrehozása Java

Ha create annotation reply java PDF-ekhez kell, akár szerződés‑ellenőrző portált, e‑learning rendszert vagy tömeges feldolgozási csővezetéket építesz, ez az útmutató pontosan megmutatja, hogyan teheted ezt meg a GroupDocs.Annotation for Java segítségével. Végigvezetünk a beállításon, a hullámos annotáció létrehozásán, a válasz szálakon és a teljesítményhangoláson, hogy napok, nem hetek alatt szállíthass megbízható megoldást.

Gyors válaszok

  • Mi a GroupDocs.Annotation elsődleges célja? Lehetővé teszi a PDF-annotációk programozott létrehozását, módosítását és kinyerését Java‑ban.
  • Hogyan adhatok hozzá hullámos annotációt? Hozd létre a SquigglyAnnotation példányt, állítsd be a geometriát és a stílust, majd hívd a annotator.add(...) metódust.
  • Csatolhatok válaszokat egy annotációhoz? Igen—hozz létre Reply objektumokat, állítsd be a szerzőt és a szöveget, és társítsd őket a szülő annotációhoz.
  • Szükségem van licencre a termeléshez? Teljesen szükséges; érvényes licenc nélkül a kimenet vízjelet tartalmaz.
  • Alkalmas-e kötegelt feldolgozásra? Igen—használd a try‑with‑resources szerkezetet minden dokumentum megnyitásához, annotálásához és bezárásához, így alacsony a memóriahasználat.

Miért van szükség Java fejlesztőknek PDF annotációkönyvtárakra

A PDF‑ek kézi megjelölése időigényes és hibára hajlamos, különösen, ha több száz szerződést vagy vizsgalapot kell átnézni. Egy Java PDF annotációkönyvtár automatizálja ezt a munkát, lehetővé téve kiemelések, hullámos aláhúzások és szálas megjegyzések beágyazását közvetlenül a fájlba. Az eredmény egy kereshető, hordozható dokumentum, amely megőrzi az összes megjelölést anélkül, hogy külön megjelenítőre lenne szükség.

Mit fogsz elsajátítani ebben az útmutatóban

  • A GroupDocs.Annotation telepítése és licencelése Maven projektben
  • Hullámos annotációk létrehozása, amelyek úgy néznek ki, mint a natív Word aláhúzások
  • Szálas válaszok hozzáadása bármely annotációhoz az együttműködő felülvizsgálathoz
  • Memória- és CPU-használat optimalizálása nagy PDF‑ek feldolgozásakor
  • A megoldás telepítése Spring Boot, mikro‑szolgáltatások vagy asztali alkalmazások környezetében

Akár jogi dokumentumfelülvizsgálati rendszert, oktatási értékelő eszközt vagy automatizált minőség‑ellenőrzési csővezetéket építesz, az alábbi technikák egy termelésre kész alapot biztosítanak.

Mi az a create annotation reply java?

create annotation reply java a programozott folyamat, amely Java használatával egy megjegyzés szálat (Reply) csatol egy meglévő PDF‑annotációhoz. A válaszok lehetővé teszik, hogy több értékelő egy adott megjelölést a dokumentum elhagyása nélkül vitasson meg, zökkenőmentes, helyben történő együttműködést biztosítva. Ez a képesség egy statikus PDF‑et interaktív megbeszélő platformmá alakítja, megőrizve a kontextust és az audit nyomvonalakat közvetlenül a fájlban.

Előfeltételek: A környezet előkészítése

Mielőtt a kódba merülnénk, ellenőrizd, hogy a fejlesztői munkaállomásod megfelel‑e az alábbi specifikációknak:

  • JDK 8 vagy újabb (JDK 11 + ajánlott a jobb szemétgyűjtési teljesítményért)
  • Maven vagy Gradle a függőségkezeléshez (a példák Maven‑t használnak)
  • Egy IDE Maven támogatással (IntelliJ IDEA, Eclipse vagy VS Code)
  • Legalább 2 GB szabad RAM az IDE‑hez és a teszt futtatásokhoz
  • Minta PDF fájlok a kísérletezéshez (egyszerű PDF‑eket bármely PDF szerkesztővel generálhatsz)

A GroupDocs.Annotation teljesen a folyamaton belül fut; külső PDF‑megjelenítő vagy natív könyvtárak nem szükségesek.

A GroupDocs.Annotation beállítása Java‑hoz

A könyvtár integrálása néhány lépésből áll, de néhány rejtett buktató futásidejű hibákat okozhat, ha figyelmen kívül hagyod őket.

Maven függőség konfiguráció

pom.xml‑hez add hozzá a tárolót és a függőséget. Helyezd a <repositories> elemet a <dependencies> előtt, hogy a Maven fel tudja oldani a csomagot.

<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 tip: Ellenőrizd a GroupDocs kiadási oldalt a legújabb verzióért. Az új kiadások gyakran tartalmaznak támogatást az új PDF szabványokhoz és teljesítményjavításokat.

Licenc beállítása (Ne hagyd ki!)

A GroupDocs.Annotation licencfájlt igényel a termeléshez. Nélküle minden generált PDF vízjelet kap.

  1. Ingyenes próba – Teljes funkciókészlet 30 napra, ideális értékeléshez.
  2. Ideiglenes licenc – Jó fejlesztéshez és belső teszteléshez.
  3. Teljes licenc – Szükséges bármely kereskedelmi telepítéshez.

Helyezd a GroupDocs.Annotation.lic fájlt a resources mappába, és töltsd be indításkor:

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

Gyakori hiba: A licenc lépés elfelejtése vízjelezett PDF‑eket és csendben sikertelen API hívásokat eredményez. Mindig ellenőrizd a licencet a start rutin elején.

Teljes megvalósítási útmutató: Hullámos annotációk hozzáadása

Az alábbi lépésről‑lépésre útmutató bemutatja, hogyan create annotation reply java egy hullámos annotáció építése közben. Minden lépés egy tömör magyarázatot tartalmaz, így megérted a „miért” minden sor mögött.

1. lépés: Az összes szükséges osztály importálása

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 a belépési pont minden dokumentumszintű művelethez.
  • Point egy koordinátát jelöl egy oldalon (X és Y a bal‑felső saroktól mérve).
  • SquigglyAnnotation a hibák kiemelésére használt hullámos aláhúzást definiálja.
  • Reply a annotációhoz csatolt szálas megjegyzéseket tárolja.
  • SaveOptions lehetővé teszi a kimeneti formátum és tömörítés szabályozását.

2. lépés: Hullámos annotáció létrehozása és konfigurálása

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

A SquigglyAnnotation egy osztály, amely hullámos aláhúzást hoz létre a PDF hibáinak kiemeléséhez.

  • Koordináta rendszer: A pontok a bal‑felső sarokból indulnak. A fenti két pont egy vízszintes hullámos vonalat rajzol (100, 200) és (300, 200) között.
  • Átlátszatlanság 0,7 azt jelenti, hogy az annotáció 70 % átlátszatlan, így az alatta lévő szöveg olvasható marad.

3. lépés: Interaktív válaszok hozzáadása (opcionális, de hatékony)

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

A Reply egy osztály, amely egy annotációhoz csatolt megjegyzés szálat képvisel.

  • A válaszok szálas beszélgetést hoznak létre közvetlenül az annotáción, tükrözve a modern PDF‑értékelők élményét.
  • Minden válasz szerzői információt és időbélyeget tárol, amelyet később szűrhetsz vagy megjeleníthetsz a felhasználói felületen.

4. lépés: Annotáció alkalmazása és dokumentum mentése

try (Annotator annotator = new Annotator("input.pdf")) {
    annotator.add(squiggly);
    SaveOptions options = new SaveOptions();
    options.setOutputPath("output.pdf");
    annotator.save(options);
}
  • A try‑with‑resources szerkezet automatikusan bezárja a Annotator‑t, felszabadítva a fájlkezelőket és natív puffereket.
  • A save a módosított PDF‑et az output.pdf fájlba írja.

Memória megjegyzés: A Annotator csak azokat az oldalakat tölti be, amelyeket érintesz. Több száz oldalas PDF‑ek esetén ez a megközelítés a heap használatot 150 MB alatt tartja egy tipikus szerveren.

Haladó konfigurációs beállítások

Annotáció megjelenés testreszabása

Finomhangolhatod a vizuális stílust, hogy megfeleljen a márka irányelveinek:

squiggly.setBorderWidth(2);
squiggly.setColor(0xFF00FF00); // ARGB green
squiggly.setOpacity(0.5);
  • Szegély szélesség szabályozza a vonal vastagságát (pontban).
  • ARGB formátum alfa csatornát tartalmaz az átlátszósághoz.

Annotációk pontos elhelyezése

A koordináták helyes meghatározása nehéz lehet változó oldalméretekkel rendelkező PDF‑eknél. Kövesd ezt a rendszerezett megközelítést:

  1. Nyisd meg a PDF‑et egy megjelenítőben (pl. Adobe Acrobat) és jegyezd fel a célterület mérőszalag értékeit.
  2. Alakítsd át a mérőszalag értékeket pontokba (1 pont = 1/72 hüvelyk).
  3. Használd a annotator.getPageInfo(pageIndex) metódust az oldal szélességének és magasságának lekérdezéséhez, majd számítsd ki a relatív pozíciókat.

Gyakori problémák és megoldások

Probléma: Az annotációk nem jelennek meg

Legvalószínűbb okok

  • A pontok az oldal határain kívül vannak
  • A licenc nincs betöltve (a vízjel elrejti az annotációt)
  • Rossz oldal szám (az API‑ban az oldalak nullától indulnak)

Megoldási ellenőrzőlista

- 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

Probléma: Gyenge teljesítmény nagy fájlok esetén

Egy 500 oldalas PDF betöltése a memóriába lelassíthatja a szolgáltatást. Ennek mérséklése:

  • Egy oldal feldolgozása egyszerre – nyisd meg a dokumentumot, annotálj egy oldalt, ments, majd lépj a következőre.
  • Streaming – használd a Annotator streaming API‑ját a teljes dokumentum pufferelésének elkerüléséhez.
  • Gyorsítótárazás – tárold a gyakran elérhető PDF‑eket egy gyors gyorsítótárban (pl. Redis) és annotáld a gyorsítótárban lévő példányt.

Probléma: A színértékek nem működnek

A GroupDocs ARGB (Alpha, Red, Green, Blue) formátumot várja el egyszerű RGB helyett. Az 0xFFFF0000 ARGB érték teljesen átlátszatlan pirosat jelent. Ha 0xFF0000‑t adsz meg, a könyvtár helytelenül értelmezi, és fekete annotációt eredményez.

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

Teljesítmény legjobb gyakorlatai

Memória kezelés

Ha tucatnyi PDF‑et annotálsz egy kötegelt feladatban, csomagold be minden fájlt egy saját try‑with‑resources blokkba:

for (String filePath : pdfList) {
    try (Annotator annotator = new Annotator(filePath)) {
        // add annotations
        annotator.save(new SaveOptions().setOutputPath(filePath.replace(".pdf", "_annotated.pdf")));
    }
}
  • Ez a minta garantálja, hogy a natív pufferek minden iteráció után felszabadulnak, megakadályozva a OutOfMemoryError hibát hosszú futású folyamatokban.

Kötegelt feldolgozás optimalizálása

Nagy áteresztőképességű környezetekben fontold meg a párhuzamos streameket egy korlátozott szálkészlettel kombinálva:

ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
pdfList.parallelStream().forEach(path -> executor.submit(() -> annotateDocument(path)));
executor.shutdown();
executor.awaitTermination(1, TimeUnit.HOURS);
  • Korlátozott pool elkerüli a szálak túlcsordulását, míg a párhuzamos streamek a CPU magokat foglalkoztatják.

Fájlméret szempontok

A nagy PDF‑ek (> 100 MB) rontják a teljesítményt. Alkalmazd ezeket a stratégiákat:

  • Elő‑tömörítés a forrás PDF‑et egy Ghostscript‑szerű eszközzel az annotáció előtt.
  • Csak a szükséges oldalakat annotáld – hagyd ki azokat az oldalakat, amelyeknek nincs szükségük megjelölésre.
  • Oszd fel a dokumentumot logikai szakaszokra (pl. fejezetenként) és dolgozd fel minden részt önállóan.

Valós alkalmazások

Dokumentum felülvizsgálati rendszerek

A jogi cégek gyakran kell, hogy jelöljék a problémás záradékokat. A hullámos annotációk és a szálas válaszok lehetővé teszik, hogy több ügyvéd egy bekezdést a PDF elhagyása nélkül vitasson meg:

  • Lawyer A piros hullámot ad egy záradék alá, és beírja: „Kétértelmű megfogalmazás”.
  • Lawyer B válaszol: „Adj hozzá definíciót a ‘lényegi szerződésszegés’ kifejezéshez”.
  • Az egész megbeszélés beágyazott, kereshető és auditálható marad.

Integráció meglévő rendszerekkel

A GroupDocs.Annotation zökkenőmentesen működik népszerű Java keretrendszerekkel:

  • Spring Boot – egy REST végpontot (/api/annotate) tesz elérhetővé, amely PDF multipart feltöltést fogad, annotációkat ad hozzá, és visszaadja az eredményt.
  • JSF – az annotációs műveleteket UI komponensekhez köti, lehetővé téve a helyben történő megjelölést egy webes nézetben.
  • Mikroszolgáltatások – a könyvtár kis lábnyoma (< 15 MB) lehetővé teszi, hogy Dockerrel konténerizáld és horizontálisan skálázd.

Munkafolyamat automatizálás

Kombináld az annotációt más GroupDocs termékekkel (pl. GroupDocs.Signature) teljes körű csővezetékek építéséhez:

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

Mikor használjunk hullámos annotációkat a alternatívákkal szemben

Használati esetAjánlott annotáció
Helyesírási vagy nyelvtani hibák jelöléseSquiggly – vizuális jelzés, hasonló a szövegszerkesztőkhöz
Fontos szakaszok kiemelése anélkül, hogy hibát sugallnaHighlight – áttetsző fedő
Részletes visszajelzés nyújtásaText vagy Comment – szabad formájú jegyzetdoboz
Dokumentum jóváhagyása vagy elutasításaStamp – „Approved” vagy „Rejected” jelvény

Következtetés

Most már egy teljes, termelésre kész recepted van a create annotation reply java használatához a GroupDocs.Annotation segítségével. Az API elsajátításával, a licenc kezelésével és a fenti teljesítmény tippek alkalmazásával képes vagy:

  • Hibajelölés automatizálása több ezer PDF‑en
  • Kollaboratív, szálas megbeszélések engedélyezése a fájlon belül
  • Alacsony memóriahasználat fenntartása még hatalmas dokumentumok feldolgozása esetén is

Következő lépések

  1. Kísérletezz más annotáció típusokkal (kiemelések, bélyegek, szöveg).
  2. Építs egy REST szolgáltatást, amely PDF‑eket fogad, annotálja őket, és visszaadja az eredményt.
  3. Fedezd fel a kinyerési API‑t (annotator.get()), hogy meglévő megjegyzéseket nyerj ki elemzéshez.

A programozott PDF‑annotáció ereje abban rejlik, hogy képes helyettesíteni a fáradságos manuális megjelölést ismételhető, auditálható kóddal. Akár egy speciális legal‑tech terméket, akár egy általános dokumentum munkafolyamat motorát építed, az útmutató technikái szilárd alapot adnak a továbblépéshez.

Gyakran Ismételt Kérdések

Q: Mi teszi a GroupDocs.Annotation‑t jobbá, mint más Java PDF könyvtárakat?
A: A GroupDocs.Annotation kizárólag az annotációs munkafolyamatokra fókuszál, több mint 30 annotáció típust, szálas válaszokat és natív támogatást nyújt 50 + fájlformátumhoz, miközben a memória lábnyoma 500 oldalas PDF‑eknél 200 MB alatt marad.

Q: Használhatom ezt a könyvtárat Spring Boot alkalmazásokkal?
A: Teljesen. Hozz létre egy @RestController‑t, amely befecskendezi a Annotator szolgáltatást, feldolgozza a multipart feltöltéseket, és visszaadja a annotált PDF‑et a kliensnek. Ne felejtsd konfigurálni a szálkészletet a párhuzamos kérésekhez.

Q: Hogyan kezelem a különböző oldalméretekkel rendelkező dokumentumokat?
A: Kérdezd le minden oldal méreteit a annotator.getPageInfo(pageIndex) segítségével, és számítsd ki a relatív koordinátákat (pl. százalékos) a pontértékek helyett. Ez biztosítja, hogy az annotációk helyesen jelenjenek meg A4, Letter és egyedi méretű oldalakon.

Q: Van mód a meglévő annotációk kinyerésére a PDF‑ekből?
A: Igen. Hívd a annotator.get()‑t, hogy lekérd az összes annotáció gyűjteményét, majd iterálj a tulajdonságok (szerző, megjegyzés, geometria) olvasásához. Ez hasznos migrációs vagy elemzési esetekben.

Q: Mi a legjobb megközelítés az annotációs jogosultságok kezelésére többfelhasználós rendszerekben?
A: Valósíts meg hitelesítést az alkalmazás rétegben, tárold a felhasználó azonosítót minden Reply‑nél, és érvényesítsd az üzleti szabályokat (pl. csak a szerző vagy egy admin szerkesztheti vagy törölheti a választ). Az API önmagában nem kényszerít jogosultságokat, így teljes rugalmasságot biztosít.

Q: Hogyan optimalizáljam a memóriahasználatot több száz PDF feldolgozásakor?
A: Használj try‑with‑resources blokkot minden dokumentumhoz, dolgozd fel az oldalakat egyenként, és fontold meg egy korlátozott szálkészlet használatát a párhuzamos memóriafogyasztás korlátozásához. A JVM heap monitorozása olyan eszközökkel, mint a VisualVM, segít finomhangolni a -Xmx beállítást.

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