Java PDF nyíl annotációk – teljes útmutató és legjobb gyakorlatok (2025)

Bevezetés

Valaha is nehézséget okozott, hogy a csapatod a PDF dokumentumok konkrét részeire összpontosítson az átnézések során? Nem vagy egyedül. Legyen szó technikai dokumentációról, jogi szerződésekről vagy projekt specifikációkról, a pontos területek kiemelése a megbeszéléshez frusztráló lehet a megfelelő eszközök nélkül.

Itt a megoldás: Java PDF nyíl annotációk a GroupDocs.Annotation API segítségével. Ez a hatékony megközelítés lehetővé teszi, hogy programozottan add arrow to pdf fájlokhoz nyilakat adj hozzá, így a közös munka zökkenőmentes és professzionális lesz. Próbaverziót a GroupDocs ideiglenes licenc oldalán szerezhetsz be.

Gyors válaszok

  • Melyik könyvtár teszi lehetővé, hogy add arrow to pdf Java‑ban? GroupDocs.Annotation for Java.
  • Szükség van licencre a termeléshez? Igen, a kereskedelmi licenc eltávolítja a vízjeleket és feloldja a teljes funkciókészletet. A részletekért lásd a GroupDocs pricing page oldalt.
  • Melyik Java‑verzió ajánlott? A JDK 11 a legjobb teljesítményt és hosszú távú támogatást nyújtja.
  • Hozzáadhatok több nyilat egy dokumentumhoz? Természetesen – egyszerűen hozz létre több ArrowAnnotation objektumot, és add hozzá ugyanahhoz a Annotator‑hez.
  • Támogatott a kötegelt feldolgozás? Igen, ciklusba teheted a dokumentumokat, és újra felhasználhatod ugyanazt a Annotator példányt a megfelelő felszabadítás után.

Mi az add arrow to pdf?

Az add arrow to pdf művelet egy irányt mutató jelölőt rajzol a PDF oldalra, hogy kiemeljen vagy rámutasson egy adott területre. A nyíl annotációk PDF objektumként tárolódnak, így bármely szabványos nézőben láthatóak maradnak, és később szerkeszthetők vagy megválaszolhatók.

Miért válaszd a GroupDocs.Annotation‑t Java PDF nyíl annotációkhoz?

A GroupDocs.Annotation gazdag annotációtípus‑készletet, vállalati szintű támogatást és egy egyszerű Java API‑t kínál, amely csökkenti a felesleges kódot. Alternatívákkal összehasonlítva 50+ bemeneti és kimeneti formátumot támogat, és 500 oldalas PDF‑eket képes kezelni 200 MB alatti heap memória felhasználással, köszönhetően a streaming architektúrának.

Előfeltételek – amire ténylegesen szükséged van

Szükséges könyvtárak és függőségek

Először add hozzá a GroupDocs.Annotation Maven függőséget. Az alábbi kódrészlet pontosan a szükséges koordinátákat tartalmazza; cseréld le a verzióhelyettesítőt a legújabb stabil kiadásra.

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

Pro tipp: Nézd meg a GroupDocs kiadási oldalt a legfrissebb verziószámért. Az új kiadások gyakran tartalmaznak teljesítményjavításokat és további annotációstílusokat.

Környezet beállítása, ami nem okoz fejfájást

  • JDK 8 vagy újabb – A JDK 11 ajánlott a fejlettebb szemétgyűjtő és modulrendszer miatt.
  • Maven 3.6+ – A régebbi Maven verziók nehezen kezelhetik a transzitiv függőségeket.
  • IDE – Az IntelliJ IDEA vagy az Eclipse a legjobb hibakeresési élményt nyújtja Java könyvtárakhoz.
  • Memória – Legalább 2 GB heap memóriát allokálj, ha 100 oldalnál nagyobb PDF‑ekkel dolgozol.

Tudás‑előfeltételek (légy őszinte magaddal)

A következőkkel kell jártasnak lenned:

  • Alapvető Java gyűjtemények és kivételkezelés.
  • Maven függőségkezelés.
  • Alap fájl‑I/O (bináris adatfolyamok olvasása és írása).

Ha bármelyik terület bizonytalan, érdemes egy gyors frissítést végezni, mielőtt belemerülnél az annotációs kódba.

A GroupDocs.Annotation beállítása – a helyes módon

1. lépés: Maven konfiguráció (hibakereséssel)

Add hozzá a korábban bemutatott tárolót és függőséget. Ha a Maven nem tudja feloldani a csomagot, ellenőrizd, hogy a GroupDocs nyilvános tárolója szerepel‑e a pom.xml‑ben:

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

2. lépés: Licenc beállítása (kritikus a termeléshez)

Fejlesztés során használhatsz ideiglenes próbaverzió licencet:

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

Valóság ellenőrzése: A próba licenc minden mentett PDF‑hez látható vízjelet ad. A termelési licenc eltávolítja ezt a vízjelet, és feloldja a teljes annotációs funkciókészletet.

3. lépés: Alap inicializációs minta

Az Annotator az elsődleges osztály egy PDF dokumentum betöltéséhez és annotációk alkalmazásához.
Mindig tedd az Annotator‑t egy try‑finally blokkba, hogy az alatta lévő erőforrások gyorsan felszabaduljanak:

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

Miért a try‑finally blokk? A GroupDocs natív memóriát foglal a PDF‑elemzéshez; ha nem szabadítod fel az Annotator‑t, memória‑szivárgás léphet fel, különösen nagy mennyiségű dokumentum kötegelt feldolgozásakor.

Teljes megvalósítási útmutató – nulláról a termelésig

A nyíl annotációk megértése kontextusban

A nyíl annotációk vizuális jelzések a dokumentum‑áttekintési munkafolyamatokban. Tipikus felhasználási esetek:

  1. Áttekintési visszajelzés – „Ez a pont tisztázásra szorul.”
  2. Referencia hivatkozás – „Lásd a 12. oldalon lévő diagramot.”
  3. Folyamatirányítás – „Itt kezdődjön az audit.”
  4. Hiba kiemelése – „Lehetséges elütés ebben a bekezdésben.”

Az annotációs UI tervezése ezek köré segít a felhasználóknak gyorsabban elfogadni az eszközt.

1. lépés: Annotációs válaszok építése (okos módon)

A válaszok egy statikus nyilat interaktív megbeszélési ponttá alakítanak. Az első alkalommal, amikor a Reply osztályt említed, határozd meg röviden:

Definíciós horgony: Reply egy szöveges megjegyzést képvisel, amely egy annotációhoz kapcsolódik, és tárolja a szerző információit és az időbélyeget.

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

Pro tipp: Tárold a felhasználó azonosítóját és szerepkörét a válasz metaadataiban; ez később egyszerűvé teszi a kommentek szűrését.

2. lépés: A nyíl annotáció létrehozása (valós‑világi szempontokkal)

Definíciós horgony: ArrowAnnotation a GroupDocs objektum, amely egy irányt mutató nyilat jelenít meg egy PDF oldalon.

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

A kulcsparaméterek magyarázata:

  • Rectangle coordinates – (x, y, width, height), ahol (x, y) a keret bal‑felső sarka.
  • PenColor – ARGB egész szám; a 65535 élénk kéket eredményez. Egy online konverterrel testreszabhatod a színeket.
  • PenStyle – Lehetőségek: DOT, DASH, SOLID, DASHDOT, DASHDOTDOT. A legtöbb esetben a SOLID a megfelelő választás.
  • Opacity – 0.0 (átlátszó) és 1.0 (átlátszatlan) között mozog. A 0.7 érték egyensúlyt teremt a láthatóság és a háttér tartalom olvashatósága között.

3. lépés: Hozzáadás és mentés (hibakezeléssel)

Definíciós horgony: Annotator.save menti az összes függőben lévő annotációs változást a cél‑PDF fájlba.

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

Mindig kezeld az IOException‑t és az AnnotationException‑t, hogy a sérült fájlok, érvénytelen útvonalak vagy jogosultsági problémák megfelelően legyenek kezelve. A stack trace naplózása segít a termelési hibák diagnosztizálásában.

Gyakori buktatók és elkerülési módok

Probléma 1: A koordináták nem egyeznek a várt pozícióval

Probléma: A nyíl eltolódik a kívánt helytől.

Megoldás: A PDF koordináta‑origó bal‑alsó, míg a GroupDocs a bal‑felsőt várja. Alakítsd át a UI koordinátákat ennek megfelelően, vagy használd a beépített convertToPdfCoordinates segédfüggvényt:

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

Probléma 2: Az annotációk eltűnnek a mentés után

Probléma: A nyilak megjelennek a feldolgozás során, de hiányoznak a végleges PDF‑ben.

Megoldás: Ez szinte mindig licencproblémára utal. Győződj meg róla, hogy a licencfájl betöltésre kerül, mielőtt bármilyen Annotator példányt létrehoznál:

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

Probléma 3: Memória‑szivárgások kötegelt feldolgozásnál

Probléma: A JVM kifogy a heap‑memóriából, amikor több tucat PDF‑et dolgozol fel.

Megoldás: Minden Annotator példányt szabadíts fel a dokumentum befejezése után, és dolgozz kis kötegekben, hogy a memóriahasználat kiszámítható maradjon:

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

Haladó testreszabási technikák

Dinamikus nyílpozicionálás

Ha a nyilaknak a webes UI‑ban történő kattintásokra kell reagálniuk, számold ki a téglalapot a kliensoldalon, és küldd a koordinátákat a backendnek. A backend ezután példányosít egy ArrowAnnotation‑t a kapott értékekkel.

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

Nyilak stílusának testreszabása különböző felhasználási esetekhez

Változtathatod a PenColor‑t és a PenStyle‑t a jelentés közvetítésére – például piros szaggatott nyilak kritikus problémákhoz, zöld szilárd nyilak jóváhagyott szakaszokhoz.

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

Valós példák a megvalósításhoz

Szenárió 1: Dokumentum‑áttekintő rendszer

Több felhasználós áttekintő portálban minden reviewer létrehoz egy ArrowAnnotation‑t és csatol egy Reply‑t. A rendszer a válaszokat relációs adatbázisban tárolja, lehetővé téve a szálas megbeszélést minden annotációhoz.

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

Szenárió 2: Automatikus hibafelismerés

Egy elemző motor PDF‑eket vizsgál a megfelelőségi szabálysértésekért, és automatikusan piros nyilakat helyez el a problémás klauzulákra mutatva.

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

Teljesítményoptimalizálási tippek

Memória‑kezelési legjobb gyakorlatok

  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.

### CPU‑teljesítmény szempontok

- Használd ugyanazt a `Color` példányt minden nyílhoz, hogy elkerüld a felesleges objektum‑létrehozást.  
- Kerüld a beágyazott ciklusokat, amelyek ismételten azonos `PenStyle` objektumokat hoznak létre.  
- Ha sok független PDF‑ed van, fontold meg egy szálkészlet használatát, de korlátozd a párhuzamos `Annotator` példányok számát a memóriafogyasztás kontrollálása érdekében.

## Hibaelhárítási útmutató – valós problémák megoldásai

### Probléma: Az annotációk nem láthatók az Adobe Readerben

**Tünetek**: A nyilak megjelennek a saját néződben, de nem jelennek meg az Adobe Acrobatban.

**Megoldások**:

1. Mentsd a PDF‑et PDF/A‑1b kompatibilitással, hogy a maximális nézőkompatibilitás biztosított legyen:  

   ```java
// Try different save options if available
SaveOptions saveOptions = new SaveOptions();
saveOptions.setAnnotationType(AnnotationType.All);
annotator.save(outputPath, saveOptions);
  1. Ellenőrizd, hogy a PDF verzió legalább 1.7‑es; a régebbi verziók elhagyhatják az újabb annotációtípusokat.

Probléma: Gyenge teljesítmény nagy PDF‑eknél

Tünetek: Az alkalmazás lefagy vagy nem reagál, amikor 200 oldalas vagy nagyobb PDF‑eket kezel.

Megoldások:

  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. Növeld a JVM heap‑et (`-Xmx4g`) nagyon nagy dokumentumok esetén.

### Probléma: Színmegjelenítési problémák

**Tünetek**: A nyíl szürke vagy teljesen átlátszó.

**Megoldás**: Definiáld a színt ARGB formátumban, és győződj meg róla, hogy a PDF színterét **DeviceRGB**‑re állítottad:

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

A megvalósítás tesztelése

Egységtesztelés nyíl annotációkhoz

Egy szilárd egységteszt betölt egy mintapDF‑et, hozzáad egy ArrowAnnotation‑t, elmenti a fájlt, majd újra megnyitja, hogy ellenőrizze az annotációk számát és tulajdonságait:

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

Integrációs tesztelés

Futtasd ugyanazt a tesztkészletet különböző méretű PDF‑ekkel (10 oldal, 100 oldal, 500 oldal) és különböző nézőkkel (Adobe Reader, Foxit, Chrome), hogy garantáld a konzisztens megjelenítést.

Következtetés

Most már teljes eszköztárral rendelkezel a Java PDF nyíl annotációk megvalósításához a GroupDocs.Annotation segítségével. Ne feledd:

  • Szabadítsd fel az Annotator objektumokat időben.
  • Teszteld különböző PDF verziókkal és méretekkel.
  • Alkalmazd a teljesítmény‑tippeket, ha kötegelt feladatokra skálázol.
  • Stílusozd a nyilakat a megjegyzés szemi‑értelmének megfelelően.

Következő lépések: fedezd fel a többi annotációtípust, például a TextAnnotation, AreaAnnotation és WatermarkAnnotation. Ugyanazok az inicializációs és felszabadítási minták alkalmazhatók, így egy teljes funkcionalitású dokumentum‑közösmunka platformot építhetsz.

Gyakran ismételt kérdések

Q: Hozzáadhatok nyíl annotációkat jelszó‑védett PDF‑ekhez?
A: Igen, add meg a jelszót az Annotator példány létrehozásakor:

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

Q: Hogyan tudok több dokumentumot hatékonyan kötegelt feldolgozni?
A: Dolgozz kis kötegekben, használd újra ugyanazt az Annotator‑t fájlonként, és a mentés után hívd meg a dispose()‑t:

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: Mi a maximális annotációszám egy dokumentumban?
A: A GroupDocs nem szab szigorú korlátot, de a gyakorlati teljesítmény körülbelül 1 000 annotáció után romlik egy 500 oldalas PDF‑nél, hacsak nem alkalmazod a fent leírt memória‑kezelési technikákat.

Q: Testreszabhatom a nyíl formákat a szabványos opciókon túl?
A: A könyvtár szabványos nyílfejeket biztosít. Teljesen egyedi formákhoz kombinálhatsz több AreaAnnotation objektumot, vagy egy vektorgrafikára fókuszáló könyvtárra válthatsz, amely támogatja a vektor‑útvonalakat.

Q: Hogyan kezelem a különböző PDF koordináta‑rendszereket?
A: A GroupDocs automatikusan konvertál a UI bal‑felső koordináták és a PDF bal‑alsó koordinátái között. Ha eltéréseket tapasztalsz, ellenőrizd, hogy nem alkalmazol-e extra transzformációs réteget a kliensoldalon.

// 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: Mennyibe kerül a licenc a termelési használathoz?
A: A GroupDocs Developer, Site és OEM licenceket kínál. Az árak 699 $‑tól indulnak fejlesztői ülésenként évente. Látogasd meg a GroupDocs pricing page‑t a legfrissebb árakért.

Q: Hogyan integráljam ezt Spring Boot alkalmazásokba?
A: Hozz létre egy @Service bean‑t, amely magába foglalja az annotációs logikát, injektáld a kontrollereidbe, és exponálj egy REST végpontot, amely PDF‑streamet fogad és visszaadja a annotált PDF‑et.

@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: Kinyerhetem a meglévő nyíl annotációkat PDF‑ekből?
A: Igen, hívd a getAnnotations() metódust egy Annotator példányon, és szűrd a AnnotationType.Arrow típusú eredményeket.

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

További források

Utoljára frissítve: 2026-08-14
Tesztelve: GroupDocs.Annotation 25.2 for Java
Szerző: 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

Kapcsolódó oktatóanyagok