Java PDF एनोटेशन लाइब्रेरी: एनोटेशन रिप्लाई जावा बनाएं

यदि आपको PDFs के लिए create annotation reply java बनाना है—चाहे आप एक कॉन्ट्रैक्ट‑रिव्यू पोर्टल, एक ई‑लर्निंग सिस्टम, या एक बल्क‑प्रोसेसिंग पाइपलाइन बना रहे हों—यह गाइड आपको GroupDocs.Annotation for Java के साथ इसे कैसे करना है, बिल्कुल दिखाता है। हम सेटअप, स्क्विगली एनोटेशन निर्माण, रिप्लाई थ्रेडिंग, और प्रदर्शन ट्यूनिंग को कवर करेंगे ताकि आप दिनों में, हफ्तों में नहीं, एक विश्वसनीय समाधान शिप कर सकें।

त्वरित उत्तर

  • GroupDocs.Annotation का मुख्य उद्देश्य क्या है? यह जावा में PDF एनोटेशन की प्रोग्रामेटिक निर्माण, संशोधन और निष्कर्षण को सक्षम करता है।
  • मैं स्क्विगली एनोटेशन कैसे जोड़ूँ? SquigglyAnnotation का इंस्टैंस बनाएं, उसकी ज्यामिति और शैली सेट करें, फिर annotator.add(...) कॉल करें।
  • क्या मैं एनोटेशन पर रिप्लाई संलग्न कर सकता हूँ? हाँ—Reply ऑब्जेक्ट बनाएं, लेखक और टेक्स्ट सेट करें, और उन्हें पैरेंट एनोटेशन से जोड़ें।
  • उत्पादन के लिए लाइसेंस आवश्यक है? बिल्कुल; वैध लाइसेंस के बिना आउटपुट में वॉटरमार्क रहेगा।
  • क्या यह बैच प्रोसेसिंग के लिए उपयुक्त है? हाँ—प्रत्येक दस्तावेज़ खोलने, एनोटेट करने और बंद करने के लिए try‑with‑resources का उपयोग करें, जिससे मेमोरी उपयोग कम रहे।

जावा डेवलपर्स को PDF एनोटेशन लाइब्रेरी क्यों चाहिए

PDF को मैन्युअल रूप से मार्क करना समय‑साध्य और त्रुटिप्रवण होता है, विशेषकर जब आपको सैकड़ों अनुबंधों या परीक्षा पत्रों की समीक्षा करनी हो। एक जावा PDF एनोटेशन लाइब्रेरी इस काम को स्वचालित करती है, जिससे आप फ़ाइल में सीधे हाइलाइट, स्क्विगली अंडरलाइन और थ्रेडेड कमेंट एम्बेड कर सकते हैं। परिणामस्वरूप एक सर्चेबल, पोर्टेबल दस्तावेज़ मिलता है जो सभी मार्कअप को बनाए रखता है बिना किसी अलग व्यूअर की आवश्यकता के।

आप इस गाइड में क्या सीखेंगे

  • Maven प्रोजेक्ट में GroupDocs.Annotation को इंस्टॉल और लाइसेंस करना
  • ऐसे स्क्विगली एनोटेशन बनाना जो मूल Word अंडरलाइन जैसा दिखे
  • सहयोगी समीक्षा के लिए किसी भी एनोटेशन में थ्रेडेड रिप्लाई जोड़ना
  • बड़े PDF प्रोसेस करते समय मेमोरी और CPU उपयोग को अनुकूलित करना
  • समाधान को Spring Boot, माइक्रो‑सर्विसेज़ या डेस्कटॉप ऐप्स में डिप्लॉय करना

चाहे आप एक कानूनी दस्तावेज़ समीक्षा प्रणाली, शैक्षिक ग्रेडिंग टूल, या स्वचालित क्वालिटी‑कंट्रोल पाइपलाइन बना रहे हों, नीचे दी गई तकनीकें आपको प्रोडक्शन‑रेडी आधार प्रदान करेंगी।

create annotation reply java क्या है?

create annotation reply java जावा का उपयोग करके मौजूदा PDF एनोटेशन से एक टिप्पणी थ्रेड (Reply) संलग्न करने की प्रोग्रामेटिक प्रक्रिया है। रिप्लाई कई समीक्षकों को दस्तावेज़ छोड़े बिना किसी विशिष्ट मार्कअप पर चर्चा करने की अनुमति देते हैं, जिससे सहज, इन‑प्लेस सहयोग संभव होता है। यह क्षमता एक स्थैतिक PDF को एक इंटरैक्टिव चर्चा प्लेटफ़ॉर्म में बदल देती है, जिससे संदर्भ और ऑडिट ट्रेल सीधे फ़ाइल में संरक्षित रहते हैं।

पूर्वापेक्षाएँ: अपना वातावरण तैयार करना

  • JDK 8 या उससे ऊपर (बेहतर गार्बेज‑कलेक्शन प्रदर्शन के लिए JDK 11 + की सिफारिश की जाती है)
  • Maven या Gradle डिपेंडेंसी मैनेजमेंट के लिए (उदाहरण Maven का उपयोग करते हैं)
  • Maven समर्थन वाला IDE (IntelliJ IDEA, Eclipse, या VS Code)
  • IDE और टेस्ट रन के लिए कम से कम 2 GB फ्री RAM
  • प्रयोग के लिए नमूना PDF फ़ाइलें (आप किसी भी PDF एडिटर से सरल PDF बना सकते हैं)

GroupDocs.Annotation पूरी तरह से इन‑प्रोसेस चलता है; कोई बाहरी PDF व्यूअर या नेटिव लाइब्रेरी आवश्यक नहीं है।

जावा के लिए GroupDocs.Annotation सेटअप करना

लाइब्रेरी को इंटीग्रेट करना कुछ‑स्टेप प्रक्रिया है, लेकिन कुछ छिपे हुए जाल यदि आप चूक जाएँ तो रनटाइम एरर का कारण बन सकते हैं।

Maven डिपेंडेंसी कॉन्फ़िगरेशन

pom.xml में रिपॉज़िटरी और डिपेंडेंसी जोड़ें। Maven को आर्टिफैक्ट रिज़ॉल्व करने के लिए <repositories> एलिमेंट को <dependencies> से पहले रखें।

<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: नवीनतम संस्करण के लिए GroupDocs रिलीज़ पेज देखें। नई रिलीज़ अक्सर उभरते PDF मानकों और प्रदर्शन सुधारों के समर्थन को शामिल करती हैं।

लाइसेंस सेटअप (इसे न छोड़ें!)

GroupDocs.Annotation को प्रोडक्शन उपयोग के लिए लाइसेंस फ़ाइल की आवश्यकता होती है। इसके बिना, प्रत्येक जेनरेटेड PDF में वॉटरमार्क रहेगा।

  1. Free Trial – 30 दिनों के लिए पूर्ण फीचर सेट, मूल्यांकन के लिए आदर्श।
  2. Temporary License – विकास और आंतरिक परीक्षण के लिए उपयुक्त।
  3. Full License – किसी भी व्यावसायिक डिप्लॉयमेंट के लिए आवश्यक।

GroupDocs.Annotation.lic फ़ाइल को अपने resources फ़ोल्डर में रखें और स्टार्टअप पर लोड करें:

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

Common gotcha: लाइसेंस चरण को भूलने से वॉटरमार्क वाले PDF और API कॉल्स जो चुपचाप फेल हो जाते हैं, उत्पन्न होते हैं। हमेशा अपने स्टार्टअप रूटीन में लाइसेंस को जल्दी वैलिडेट करें।

पूर्ण इम्प्लीमेंटेशन गाइड: स्क्विगली एनोटेशन जोड़ना

नीचे एक स्टेप‑बाय‑स्टेप walkthrough दिया गया है जो create annotation reply java बनाते हुए स्क्विगली एनोटेशन बनाने को दिखाता है। प्रत्येक चरण में संक्षिप्त व्याख्या शामिल है, ताकि आप प्रत्येक लाइन के पीछे का “क्यों” समझ सकें।

चरण 1: सभी आवश्यक क्लासेस इम्पोर्ट करें

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 सभी दस्तावेज़‑स्तर ऑपरेशन्स के लिए एंट्री पॉइंट है।
  • Point पेज पर एक कोऑर्डिनेट दर्शाता है (X और Y टॉप‑लेफ़्ट से मापे जाते हैं)।
  • SquigglyAnnotation त्रुटियों को हाइलाइट करने के लिए उपयोग किए जाने वाले वेवि अंडरलाइन को परिभाषित करता है।
  • Reply एनोटेशन से जुड़ी थ्रेडेड कमेंट्स को स्टोर करता है।
  • SaveOptions आपको आउटपुट फॉर्मेट और कंप्रेशन को नियंत्रित करने देता है।

चरण 2: अपना स्क्विगली एनोटेशन बनाएं और कॉन्फ़िगर करें

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 एक क्लास है जो PDF में त्रुटियों को हाइलाइट करने के लिए वेवि अंडरलाइन बनाता है।

  • कोऑर्डिनेट सिस्टम: पॉइंट्स टॉप‑लेफ़्ट कोने से शुरू होते हैं। ऊपर के दो पॉइंट्स (100, 200) से (300, 200) तक एक क्षैतिज वेवि लाइन बनाते हैं।
  • Opacity 0.7 का मतलब है एनोटेशन 70 % अपारदर्शी है, जिससे नीचे का टेक्स्ट पढ़ने योग्य रहता है।

चरण 3: इंटरैक्टिव रिप्लाई जोड़ें (वैकल्पिक लेकिन शक्तिशाली)

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 एक क्लास है जो एनोटेशन से जुड़ी टिप्पणी थ्रेड को दर्शाता है।

  • रिप्लाई सीधे एनोटेशन पर थ्रेडेड डिस्कशन बनाते हैं, जो आधुनिक PDF समीक्षकों के अनुभव को प्रतिबिंबित करता है।
  • प्रत्येक रिप्लाई लेखक जानकारी और टाइमस्टैम्प स्टोर करता है, जिसे आप बाद में फ़िल्टर या UI में दिखा सकते हैं।

चरण 4: एनोटेशन लागू करें और दस्तावेज़ सहेजें

try (Annotator annotator = new Annotator("input.pdf")) {
    annotator.add(squiggly);
    SaveOptions options = new SaveOptions();
    options.setOutputPath("output.pdf");
    annotator.save(options);
}
  • try‑with‑resources कंस्ट्रक्ट स्वचालित रूप से Annotator को बंद करता है, फ़ाइल हैंडल और नेटिव बफ़र्स को रिलीज़ करता है।
  • save संशोधित PDF को output.pdf में लिखता है।

Memory note: Annotator केवल उन पेजों को लोड करता है जिन्हें आप टच करते हैं। कई‑सौ पेज वाले PDF के लिए, यह तरीका सामान्य सर्वर पर हीप उपयोग को 150 MB से कम रखता है।

उन्नत कॉन्फ़िगरेशन विकल्प

एनोटेशन की उपस्थिति को कस्टमाइज़ करना

आप विज़ुअल स्टाइल को अपने ब्रांड गाइडलाइन के अनुसार फाइन‑ट्यून कर सकते हैं:

squiggly.setBorderWidth(2);
squiggly.setColor(0xFF00FF00); // ARGB green
squiggly.setOpacity(0.5);
  • Border width लाइन की मोटाई (पॉइंट्स में) नियंत्रित करता है।
  • ARGB फ़ॉर्मेट में ट्रांसपैरेंसी के लिए अल्फा चैनल शामिल है।

एनोटेशन को सटीक रूप से पोज़िशन करना

विभिन्न पेज साइज वाले PDF में कोऑर्डिनेट सही ढंग से प्राप्त करना मुश्किल हो सकता है। इस व्यवस्थित दृष्टिकोण का पालन करें:

  1. PDF को एक व्यूअर में खोलें (जैसे, Adobe Acrobat) और लक्ष्य क्षेत्र के लिए रूलर वैल्यू नोट करें।
  2. रूलर वैल्यू को पॉइंट्स में बदलें (1 point = 1/72 inch)।
  3. annotator.getPageInfo(pageIndex) का उपयोग करके पेज की चौड़ाई और ऊँचाई प्राप्त करें, फिर रिलेटिव पोज़िशन की गणना करें।

सामान्य समस्याएँ और समाधान

समस्या: एनोटेशन नहीं दिख रहे हैं

सबसे संभावित कारण

  • पॉइंट्स पेज की सीमाओं के बाहर हैं
  • लाइसेंस लोड नहीं हुआ (वॉटरमार्क एनोटेशन को छुपा देता है)
  • गलत पेज नंबर (API में पेजेज़ ज़ीरो‑बेस्ड हैं)

समाधान चेकलिस्ट

- 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

समस्या: बड़े फ़ाइलों के साथ खराब प्रदर्शन

500‑पेज PDF को मेमोरी में लोड करना आपकी सेवा को रोक सकता है। इसे कम करने के लिए:

  • एक बार में एक पेज प्रोसेस करना – दस्तावेज़ खोलें, एक पेज को एनोटेट करें, सहेजें, फिर अगले पर जाएँ।
  • स्ट्रीमिंग – पूर्ण दस्तावेज़ बफ़रिंग से बचने के लिए Annotator की स्ट्रीमिंग API का उपयोग करें।
  • कैशिंग – अक्सर एक्सेस किए जाने वाले PDF को तेज़ कैश (जैसे, Redis) में रखें और कैश्ड कॉपी को एनोटेट करें।

समस्या: रंग मान काम नहीं कर रहे हैं

GroupDocs ARGB (Alpha, Red, Green, Blue) की अपेक्षा करता है, न कि साधारण RGB की। 0xFFFF0000 ARGB मान का मतलब पूरी तरह अपारदर्शी लाल है। यदि आप 0xFF0000 प्रदान करते हैं तो लाइब्रेरी इसे गलत समझती है, जिससे काली एनोटेशन बनती है।

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

प्रदर्शन सर्वश्रेष्ठ प्रथाएँ

मेमोरी प्रबंधन

बैच जॉब में दर्जनों PDF को एनोटेट करते समय, प्रत्येक फ़ाइल को अपने स्वयं के try‑with‑resources ब्लॉक में रैप करें:

for (String filePath : pdfList) {
    try (Annotator annotator = new Annotator(filePath)) {
        // add annotations
        annotator.save(new SaveOptions().setOutputPath(filePath.replace(".pdf", "_annotated.pdf")));
    }
}
  • यह पैटर्न सुनिश्चित करता है कि प्रत्येक इटरेशन के बाद नेटिव बफ़र्स रिलीज़ हो जाएँ, जिससे लंबी‑चलने वाली प्रक्रियाओं में OutOfMemoryError से बचा जा सके।

बैच प्रोसेसिंग अनुकूलन

हाई‑थ्रूपुट वातावरण के लिए, बाउंडेड थ्रेड पूल के साथ पैरलल स्ट्रीम्स पर विचार करें:

ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
pdfList.parallelStream().forEach(path -> executor.submit(() -> annotateDocument(path)));
executor.shutdown();
executor.awaitTermination(1, TimeUnit.HOURS);
  • Bounded pool थ्रेड एक्सप्लोजन से बचाता है, जबकि पैरलल स्ट्रीम्स CPU कोर को व्यस्त रखते हैं।

फ़ाइल आकार विचार

बड़े PDF (> 100 MB) प्रदर्शन को घटा सकते हैं। इन रणनीतियों को लागू करें:

  • Pre‑compress स्रोत PDF को Ghostscript जैसे टूल से एनोटेशन से पहले संपीड़ित करें।
  • केवल आवश्यक पेजों को एनोटेट करें – उन पेजों को स्किप करें जिनमें मार्कअप की आवश्यकता नहीं है।
  • दस्तावेज़ को लॉजिकल सेक्शन (जैसे, प्रति चैप्टर) में स्प्लिट करें और प्रत्येक चंक को स्वतंत्र रूप से प्रोसेस करें।

वास्तविक‑विश्व अनुप्रयोग

दस्तावेज़ समीक्षा प्रणाली

कानूनी फर्मों को अक्सर समस्याग्रस्त क्लॉज़ को फ़्लैग करना पड़ता है। स्क्विगली एनोटेशन और थ्रेडेड रिप्लाई कई वकीलों को एक पैराग्राफ पर PDF छोड़े बिना चर्चा करने देते हैं:

  • Lawyer A एक क्लॉज़ के नीचे लाल स्क्विगली जोड़ता है और “अस्पष्ट शब्दावली” लिखता है।
  • Lawyer B जवाब देता है “‘material breach’ के लिए परिभाषा जोड़ें”。
  • पूरी चर्चा एम्बेडेड, सर्चेबल और ऑडिटेबल रहती है।

मौजूदा सिस्टम के साथ इंटीग्रेशन

GroupDocs.Annotation लोकप्रिय जावा फ्रेमवर्क्स के साथ सुगमता से काम करता है:

  • Spring Boot – एक REST endpoint /api/annotate एक्सपोज़ करें जो PDF मल्टीपार्ट अपलोड स्वीकार करता है, एनोटेशन जोड़ता है, और परिणाम को स्ट्रीम करके वापस भेजता है।
  • JSF – वेब व्यू में ऑन‑द‑फ्लाई मार्कअप के लिए एनोटेशन एक्शन को UI कंपोनेंट्स से बाइंड करें।
  • Microservices – लाइब्रेरी का छोटा फुटप्रिंट (< 15 MB) आपको इसे Docker के साथ कंटेनराइज़ करने और क्षैतिज रूप से स्केल करने देता है।

वर्कफ़्लो ऑटोमेशन

एनोटेशन को अन्य GroupDocs उत्पादों (जैसे, GroupDocs.Signature) के साथ मिलाकर एंड‑टू‑एंड पाइपलाइन बनाएं:

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

कब स्क्विगली एनोटेशन बनाम विकल्पों का उपयोग करें

उपयोग‑केसअनुशंसित एनोटेशन
वर्तनी या व्याकरण त्रुटियों को चिह्नित करनाSquiggly – वर्ड प्रोसेसर के समान विज़ुअल क्यू
बिना त्रुटि संकेत के महत्वपूर्ण सेक्शन को हाइलाइट करनाHighlight – पारदर्शी ओवरले
विस्तृत फीडबैक प्रदान करनाText या Comment – फ्री‑फ़ॉर्म नोट बॉक्स
दस्तावेज़ को स्वीकृत या अस्वीकृत करनाStamp – “Approved” या “Rejected” बैज

निष्कर्ष

अब आपके पास GroupDocs.Annotation का उपयोग करके create annotation reply java के लिए एक पूर्ण, प्रोडक्शन‑रेडी रेसिपी है। API में महारत हासिल करके, लाइसेंसिंग को संभालकर, और ऊपर दिए गए प्रदर्शन टिप्स लागू करके आप:

  • हजारों PDF में त्रुटि‑मार्किंग को ऑटोमेट करें
  • फ़ाइल के भीतर सहयोगी, थ्रेडेड डिस्कशन सक्षम करें
  • भारी दस्तावेज़ प्रोसेस करते समय भी मेमोरी उपयोग कम रखें

अगले कदम

  1. अन्य एनोटेशन प्रकारों (हाइलाइट, स्टैम्प, टेक्स्ट) के साथ प्रयोग करें।
  2. एक REST सेवा बनाएं जो PDF प्राप्त करे, उन्हें एनोटेट करे, और परिणाम वापस करे।
  3. एक्सट्रैक्शन API (annotator.get()) का अन्वेषण करें ताकि मौजूदा कमेंट्स को एनालिटिक्स के लिए निकाला जा सके।

प्रोग्रामेटिक PDF एनोटेशन की शक्ति इस बात में है कि यह थकाऊ मैन्युअल मार्कअप को दोहराने योग्य, ऑडिटेबल कोड से बदल देता है। चाहे आप एक विशेष कानूनी‑टेक प्रोडक्ट बना रहे हों या एक सामान्य‑उद्देश्य दस्तावेज़ वर्कफ़्लो इंजन, इस गाइड की तकनीकें आपको आगे बढ़ने के लिए एक ठोस आधार देती हैं।

अक्सर पूछे जाने वाले प्रश्न

Q: GroupDocs.Annotation को अन्य जावा PDF लाइब्रेरीज़ से क्या बेहतर बनाता है?
A: GroupDocs.Annotation विशेष रूप से एनोटेशन वर्कफ़्लो पर केंद्रित है, 30 से अधिक एनोटेशन प्रकार, थ्रेडेड रिप्लाई, और 50 + फ़ाइल फ़ॉर्मैट्स के लिए नेटिव सपोर्ट प्रदान करता है, जबकि 500‑पेज PDF के लिए मेमोरी फुटप्रिंट 200 MB से कम रखता है।

Q: क्या मैं इस लाइब्रेरी को Spring Boot एप्लिकेशन्स के साथ उपयोग कर सकता हूँ?
A: बिल्कुल। एक @RestController बनाएं जो Annotator सेवा को इंजेक्ट करे, मल्टीपार्ट अपलोड प्रोसेस करे, और एनोटेटेड PDF को क्लाइंट को स्ट्रीम करके वापस भेजे। समवर्ती अनुरोधों के लिए थ्रेड‑पूल कॉन्फ़िगर करना याद रखें।

Q: विभिन्न पेज साइज वाले दस्तावेज़ों को कैसे संभालूँ?
A: annotator.getPageInfo(pageIndex) के माध्यम से प्रत्येक पेज के आयाम पूछें और पॉइंट वैल्यू को हार्ड‑कोड करने के बजाय रिलेटिव कोऑर्डिनेट (जैसे, प्रतिशत) की गणना करें। इससे एनोटेशन A4, Letter, और कस्टम‑साइज़ पेजों पर सही ढंग से दिखेंगे।

Q: क्या PDF से मौजूदा एनोटेशन निकालने का कोई तरीका है?
A: हाँ। annotator.get() कॉल करके सभी एनोटेशन का कलेक्शन प्राप्त करें, फिर लेखक, कमेंट, और ज्योमेट्री जैसी प्रॉपर्टीज़ पढ़ने के लिए इटरेट करें। यह माइग्रेशन या एनालिटिक्स परिदृश्यों में उपयोगी है।

Q: मल्टी‑यूज़र सिस्टम में एनोटेशन परमिशन संभालने का सबसे अच्छा तरीका क्या है?
A: एप्लिकेशन लेयर पर ऑथेंटिकेशन लागू करें, प्रत्येक Reply के साथ यूज़र ID स्टोर करें, और बिज़नेस नियम लागू करें (जैसे, केवल लेखक या एडमिन रिप्लाई को एडिट या डिलीट कर सकते हैं)। API स्वयं परमिशन लागू नहीं करता, जिससे आपको पूरी लचीलापन मिलता है।

Q: सैकड़ों PDF प्रोसेस करते समय मेमोरी उपयोग को कैसे ऑप्टिमाइज़ करूँ?
A: प्रत्येक दस्तावेज़ के लिए try‑with‑resources का उपयोग करें, पेजों को व्यक्तिगत रूप से प्रोसेस करें, और समवर्ती मेमोरी खपत को सीमित करने के लिए बाउंडेड थ्रेड पूल पर विचार करें। VisualVM जैसे टूल्स से JVM हीप मॉनिटर करके -Xmx सेटिंग को फाइन‑ट्यून करें।

अंतिम अपडेट: 2026-05-16
टेस्ट किया गया: GroupDocs.Annotation 25.2 for Java
लेखक: GroupDocs

अतिरिक्त संसाधन

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

संबंधित ट्यूटोरियल