PDF में एनोटेशन जोड़ें
यदि आपको Java एप्लिकेशन से PDF में एनोटेशन जोड़ने की आवश्यकता है—चाहे आप एक कॉन्ट्रैक्ट‑रिव्यू पोर्टल, एक ई‑लर्निंग प्लेटफ़ॉर्म, या एक सहयोगी दस्तावेज़ संपादक बना रहे हों—यह ट्यूटोरियल आपको GroupDocs.Annotation के साथ इसे कैसे करना है, बिल्कुल दिखाता है। आप PDFs लोड करना, एरिया‑स्टाइल टिप्पणी बनाना, संसाधनों को कुशलतापूर्वक प्रबंधित करना, और बड़ी फ़ाइलों को मेमोरी समाप्त किए बिना संभालना सीखेंगे।
त्वरित उत्तर
- GroupDocs.Annotation का मुख्य उद्देश्य क्या है? Java से कई दस्तावेज़ फ़ॉर्मेट्स में एनोटेशन जोड़ने, संपादित करने और प्रबंधित करने के लिए।
- समीक्षा टिप्पणियों के लिए कौन सा एनोटेशन प्रकार सबसे अच्छा है?
AreaAnnotationएक कस्टम संदेश और उपयोगकर्ता मेटाडेटा के साथ। - क्या विकास के लिए लाइसेंस चाहिए? परीक्षण के लिए एक मुफ्त ट्रायल काम करता है; उत्पादन के लिए पूर्ण लाइसेंस आवश्यक है।
- क्या मैं 50 MB से बड़े PDFs प्रोसेस कर सकता हूँ? हाँ—स्ट्रीमिंग, बैच प्रोसेसिंग, और उचित डिस्पोज़ल का उपयोग करके मेमोरी उपयोग कम रखें।
- क्या लाइब्रेरी थ्रेड‑सेफ़ है? इंस्टेंस थ्रेड‑सेफ़ नहीं हैं; प्रत्येक थ्रेड के लिए एक अलग
Annotatorबनाएं।
GroupDocs Annotation क्यों अलग है
GroupDocs.Annotation आपको PDF में एनोटेशन जोड़ने को तेज़ी से करने देता है जबकि फ़ाइल प्रकारों के एक विस्तृत इकोसिस्टम का समर्थन करता है। यह प्रदान करता है:
- व्यापक फ़ॉर्मेट समर्थन – 50+ इनपुट और आउटपुट फ़ॉर्मेट, जिसमें DOCX, PPTX, XLSX, JPEG, PNG, और TIFF शामिल हैं।
- समृद्ध एनोटेशन पैलेट – हाइलाइट, एरो, वॉटरमार्क, टेक्स्ट रिप्लेसमेंट, और कस्टम शैप्स, सभी एक ही API के माध्यम से उपलब्ध।
- एंटरप्राइज़‑रेडी फीचर्स – बिल्ट‑इन लाइसेंसिंग, स्केलेबिलिटी विकल्प, और मौजूदा Java स्टैक के साथ सहज इंटीग्रेशन।
- सक्रिय विकास – मासिक रिलीज़ में प्रदर्शन सुधार (30 % तक तेज़ रेंडरिंग) और नए एनोटेशन प्रकार शामिल होते हैं।
पूर्वापेक्षाएँ और सेटअप आवश्यकताएँ
शुरू करने से पहले आपको क्या चाहिए
- डेवलपमेंट एनवायरनमेंट – JDK 8 या बाद का (Java 11+ अनुशंसित), Maven या Gradle, और आपका पसंदीदा IDE (IntelliJ IDEA, Eclipse, या VS Code)।
- बेसिक नॉलेज – Java सिंटैक्स, फ़ाइल I/O, और Maven डिपेंडेंसी मैनेजमेंट।
- वैकल्पिक – PDF पेज कोऑर्डिनेट्स की परिचितता और अन्य Java लाइब्रेरीज़ का पूर्व अनुभव।
Java के लिए GroupDocs.Annotation सेटअप करना
Maven कॉन्फ़िगरेशन
pom.xml में GroupDocs रिपॉज़िटरी और Annotation डिपेंडेंसी जोड़ें। यदि नया संस्करण उपलब्ध है तो 25.2 को नवीनतम संस्करण से बदलें।
<!-- 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 tip: हमेशा GroupDocs वेबसाइट पर नवीनतम संस्करण की जाँच करें। नए रिलीज़ अक्सर बड़े PDFs के लिए मेमोरी खपत में 20 % तक की कमी लाते हैं।
लाइसेंसिंग विकल्प (और उनका वास्तविक अर्थ)
- Free trial – वॉटरमार्क्ड आउटपुट, मूल्यांकन के लिए उपयुक्त।
- Temporary license – 30 दिन तक बिना प्रतिबंध; एक temporary license प्राप्त करें Temporary License.
- Full license – उत्पादन डिप्लॉयमेंट के लिए आवश्यक; कीमत डिप्लॉयमेंट स्केल के अनुसार बदलती है।
प्रारंभिक सत्यापन
डिपेंडेंसी जोड़ने के बाद, यह छोटा टेस्ट चलाएँ ताकि लाइब्रेरी सही से लोड हो रही है यह पुष्टि हो सके:
<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>
Java के साथ PDF एनोटेशन कैसे बनाएं GroupDocs.Annotation के साथ
दस्तावेज़ लोड करें, एक AreaAnnotation जोड़ें, और परिणाम सहेजें। निम्नलिखित सीधा उत्तर पूरे वर्कफ़्लो का सार प्रस्तुत करता है:
new Annotator("input.pdf") से अपना PDF लोड करें, एक AreaAnnotation बनाएं जो आयत और टिप्पणी टेक्स्ट को परिभाषित करता है, एनोटेशन को Annotator में जोड़ें, फिर save("output.pdf") कॉल करें। यह तीन‑स्टेप पैटर्न किसी भी PDF आकार को संभालता है और संसाधनों को स्वचालित रूप से रिलीज़ करता है।
दस्तावेज़ लोड करना: सिर्फ फ़ाइल पाथ से अधिक
बेसिक दस्तावेज़ लोडिंग
Annotator क्लास सभी एनोटेशन ऑपरेशनों का एंट्री पॉइंट है। यह मेमोरी में एक PDF दस्तावेज़ का प्रतिनिधित्व करता है और एनोटेशन पढ़ने, संशोधित करने और सहेजने के मेथड प्रदान करता है।
Annotator annotator = new Annotator("sample.pdf");
Real‑world context: उत्पादन में, फ़ाइल पाथ अपलोड फ़ोल्डर, डेटाबेस ब्लॉब, या क्लाउड स्टोरेज URL से आ सकता है। GroupDocs.Annotation स्थानीय फ़ाइलें, InputStreams, और रिमोट URLs को अतिरिक्त कोड के बिना स्वीकार करता है।
विभिन्न इनपुट स्रोतों को संभालना
आप एक PDF को बाइट एरे या HTTP URL से भी लोड कर सकते हैं:
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());
}
}
}
अपनी पहली एनोटेशन जोड़ना
एरिया एनोटेशन को समझना
AreaAnnotation आयताकार क्षेत्र को हाइलाइट करने और टिप्पणी जोड़ने के लिए सबसे बहुमुखी प्रकार है। यह एक डिजिटल स्टिकी नोट की तरह काम करता है जिसे स्थानांतरित, आकार बदल और स्टाइल किया जा सकता है।
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");
Coordinate system explained: PDF कोऑर्डिनेट्स बॉटम‑लेफ़्ट से शुरू होते हैं, लेकिन GroupDocs टॉप‑लेफ़्ट ओरिजिन का उपयोग करता है, जो सामान्य UI फ्रेमवर्क्स के साथ मेल खाता है। मान पॉइंट्स (1/72 इंच) में व्यक्त होते हैं।
व्यावहारिक एनोटेशन उदाहरण
महत्वपूर्ण टेक्स्ट को हाइलाइट करना
HighlightAnnotation highlight = new HighlightAnnotation();
highlight.setRectangle(new Rectangle(50, 200, 300, 20));
highlight.setColor(Color.YELLOW);
annotator.add(highlight);
समीक्षा टिप्पणियां बनाना
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);
सहेजना और संसाधन प्रबंधन
उचित फ़ाइल सहेजने की तकनीकें
annotator.save("annotated.pdf");
Why dispose matters: Annotator तेज़ एक्सेस के लिए PDF की सामग्री मेमोरी में रखता है। इसे बंद न करने से मेमोरी लीक हो सकता है, विशेष रूप से बैच जॉब में कई फ़ाइलों को प्रोसेस करते समय।
बेहतर संसाधन‑प्रबंधन पैटर्न
try (Annotator annotator = new Annotator("input.pdf")) {
// add annotations here
annotator.save("output.pdf");
}
सामान्य कठिनाइयाँ और उन्हें कैसे टालें
फ़ाइल पाथ और अनुमति समस्याएँ
- Problem: “File not found” या “Access denied”。
- Solution: विकास के दौरान एब्सॉल्यूट पाथ का उपयोग करें, रीड/राइट अनुमतियों की जाँच करें, और खोलने से पहले फ़ाइल मौजूद है यह सुनिश्चित करें।
File file = new File("C:/docs/input.pdf");
if (!file.exists() || !file.canRead()) {
throw new IllegalArgumentException("File is missing or unreadable.");
}
मेमोरी प्रबंधन की गलतियाँ
- Problem: कई PDFs प्रोसेस करने के बाद एप्लिकेशन धीमा हो जाता है।
- Solution: हमेशा try‑with‑resources या स्पष्ट
close()कॉल्स का उपयोग करके नेटीव बफ़र्स को मुक्त करें।
try (Annotator annotator = new Annotator("large.pdf")) {
// process
}
कोऑर्डिनेट सिस्टम में भ्रम
- Problem: एनोटेशन स्क्रीन से बाहर दिखते हैं।
- Solution: याद रखें GroupDocs टॉप‑लेफ़्ट ओरिजिन का उपयोग करता है। डायनामिक वैल्यू लागू करने से पहले (50, 50, 100, 50) जैसे ज्ञात कोऑर्डिनेट्स के साथ परीक्षण करें।
AreaAnnotation test = new AreaAnnotation();
test.setRectangle(new Rectangle(50, 50, 100, 50));
annotator.add(test);
वास्तविक उपयोग केस और एप्लिकेशन
दस्तावेज़ समीक्षा वर्कफ़्लो
कानूनी टीमों को अक्सर यह ट्रैक करना पड़ता है कि किसने किस क्लॉज़ पर टिप्पणी की। GroupDocs.Annotation के साथ आप:
- प्रत्येक समीक्षक के लिए एक अनूठा रंग असाइन कर सकते हैं।
- एनोटेशन मेटाडेटा में टाइमस्टैम्प और यूज़र आईडी संग्रहीत कर सकते हैं।
- ऑडिट ट्रेल को संरक्षित रखते हुए क्लाइंट वितरण के लिए एनोटेटेड PDF एक्सपोर्ट कर सकते हैं।
area.setCreator("lawyer@example.com");
area.setCreatedOn(LocalDateTime.now());
शैक्षिक सामग्री निर्माण
ई‑लर्निंग प्लेटफ़ॉर्म एनोटेशन का उपयोग प्रमुख अवधारणाओं को हाइलाइट करने, क्विज़ एम्बेड करने, या अध्ययन PDFs पर सीधे व्याख्यात्मक नोट्स जोड़ने के लिए करते हैं। यह साधारण PDFs की तुलना में रिटेंशन को 35 % तक सुधारता है (आंतरिक अध्ययन)।
क्वालिटी‑अश्योरेंस दस्तावेज़ीकरण
निर्माता तकनीकी ड्रॉइंग्स पर टॉलरेंस, रिवीजन, और सुरक्षा चेतावनियों को दर्शाने के लिए एनोटेशन जोड़ते हैं। मानकीकृत मार्कअप उत्पादन लाइनों में अनुमानित 22 % रीयवर्क को कम करता है।
प्रदर्शन अनुकूलन टिप्स
बड़े दस्तावेज़ों को कुशलतापूर्वक संभालना
पेजेज़ को स्ट्रीम करने पर, पूरे फ़ाइल को लोड करने की बजाय, एक सामान्य 4‑कोर सर्वर पर 200‑पेज PDF को 2 सेकंड से कम में प्रोसेस किया जा सकता है।
Annotator annotator = new Annotator(new FileInputStream("big.pdf"));
मेमोरी‑उपयोग मॉनिटरिंग
Java के बिल्ट‑इन मॉनिटरिंग टूल्स (JVisualVM, JConsole) को सक्षम करें ताकि बड़े फ़ाइलों को एनोटेट करते समय हीप उपयोग को देखा जा सके। लक्ष्य है हीप को अधिकतम अलोकेशन के 70 % से नीचे रखना।
समवर्ती प्रोसेसिंग विचार
GroupDocs.Annotation इंस्टेंस थ्रेड‑सेफ़ नहीं हैं। समानांतर वर्कलोड्स के लिए, प्रत्येक थ्रेड के लिए एक अलग Annotator बनाएं या थ्रेड‑लोकल पूल का उपयोग करें।
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"));
}
});
}
उन्नत एनोटेशन तकनीकें
एक दस्तावेज़ में कई एनोटेशन प्रकार
आप एक ही पास में हाइलाइट, टेक्स्ट नोट, और वॉटरमार्क को मिश्रित कर सकते हैं:
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);
सामग्री के आधार पर डायनामिक एनोटेशन
GroupDocs.Annotation को Apache PDFBox या Tika के साथ संयोजित करके कीवर्ड्स को स्वचालित रूप से पहचानें और संदर्भात्मक नोट्स जोड़ें।
// pseudo‑code: detect the word "confidential"
if (pageText.contains("confidential")) {
WatermarkAnnotation wm = new WatermarkAnnotation();
wm.setText("CONFIDENTIAL");
annotator.add(wm);
}
समस्या निवारण गाइड
सामान्य त्रुटि संदेश और समाधान
- “Invalid license” – लाइसेंस फ़ाइल को क्लासपाथ पर रखें और सुनिश्चित करें कि यह आपके डिप्लॉयमेंट प्रकार से मेल खाती है।
- “Unsupported file format” – जांचें कि PDF भ्रष्ट नहीं है, पासवर्ड‑प्रोटेक्टेड नहीं है, या शून्य‑बाइट नहीं है।
- Performance slowdown – स्ट्रीमिंग का उपयोग करें,
Annotatorऑब्जेक्ट्स को तुरंत डिस्पोज़ करें, और बैच प्रोसेसिंग पर विचार करें।
डिबगिंग टिप्स
लॉगिंग सक्षम करें
System.setProperty("log4j.configurationFile", "log4j2.xml");
इनपुट वैलिडेट करें
Objects.requireNonNull(filePath, "File path cannot be null");
अक्सर पूछे जाने वाले प्रश्न
Q: मैं एक ही PDF में कई एनोटेशन को कुशलतापूर्वक कैसे जोड़ूं?
A: प्रत्येक एनोटेशन के लिए annotator.add(annotation) कॉल करें, फिर एक बार save() Invoke करें। GroupDocs बदलावों को बैच करता है और एक ही पास में लिखता है।
annotator.add(area1);
annotator.add(highlight2);
annotator.save("combined.pdf");
Q: PDF के अलावा GroupDocs.Annotation कौन से फ़ाइल फ़ॉर्मेट सपोर्ट करता है?
A: यह 50 से अधिक फ़ॉर्मेट सपोर्ट करता है, जिसमें DOC, DOCX, PPT, PPTX, XLS, XLSX, JPEG, PNG, TIFF, और कई अन्य शामिल हैं। पूरी सूची देखें GroupDocs.Annotation Documentation में।
Q: पासवर्ड‑प्रोटेक्टेड PDFs को कैसे हैंडल करूं?
Annotator annotator = new Annotator("secure.pdf", "password123");
Q: क्या मैं PDF में मौजूदा एनोटेशन को पुनः प्राप्त और संशोधित कर सकता हूँ?
List<AnnotationBase> existing = annotator.getAll();
for (AnnotationBase a : existing) {
if (a instanceof TextAnnotation) {
((TextAnnotation) a).setComment("Updated comment");
}
}
annotator.save("updated.pdf");
Q: बड़े PDFs को प्रोसेस करने के प्रदर्शन प्रभाव क्या हैं?
A: 50 MB से बड़े फ़ाइलों को पेज‑बाय‑पेज स्ट्रीम किया जाना चाहिए। प्रत्येक पेज बैच प्रोसेस करने के बाद Annotator को डिस्पोज़ करने पर मेमोरी उपयोग 150 MB से नीचे रहता है।
Q: वेब एप्लिकेशन में समवर्ती दस्तावेज़ प्रोसेसिंग को कैसे हैंडल करूं?
// each request gets its own Annotator instance
public void processPdf(String path) {
try (Annotator a = new Annotator(path)) {
// annotate
a.save(path);
}
}
Q: एनोटेशन पोजिशनिंग समस्याओं को डिबग करने का सबसे अच्छा तरीका क्या है?
A: ज्ञात आयत (जैसे (50, 50, 100, 50)) से शुरू करें और दृश्य परिणाम की पुष्टि करें। कोऑर्डिनेट्स को क्रमिक रूप से समायोजित करें और PDF के पेज साइज (आमतौर पर 612 × 792 पॉइंट्स) को देखें।
Q: GroupDocs.Annotation को 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);
}
}
}
अतिरिक्त FAQ
Q: क्या मैं एनोटेटेड PDFs को अन्य फ़ॉर्मेट में एक्सपोर्ट कर सकता हूँ?
A: हाँ, आप एनोटेटेड PDFs को DOCX, PPTX, या इमेज फ़ॉर्मेट में सभी मार्कअप को संरक्षित रखते हुए कनवर्ट कर सकते हैं।
Q: क्या लाइब्रेरी द्वारा सपोर्ट किए गए सभी एनोटेशन प्रकारों की सूची प्राप्त करने का कोई तरीका है?
A: AnnotationType.values() का उपयोग करके सभी समर्थित एनोम का एरे प्राप्त करें।
Q: वॉटरमार्क एनोटेशन की उपस्थिति को कैसे कस्टमाइज़ करूं?
A: WatermarkAnnotation पर setOpacity, setRotation, और setBackgroundColor जैसी प्रॉपर्टीज़ सेट करें, फिर इसे जोड़ें।
Q: क्या लाइब्रेरी डेटाबेस से प्रोग्रामेटिक रूप से टिप्पणियां जोड़ने का समर्थन करती है?
A: बिल्कुल। किसी भी स्रोत से टिप्पणी डेटा पढ़ें, टेक्स्ट के साथ AreaAnnotation (या TextAnnotation) को पॉप्युलेट करें, और दस्तावेज़ में जोड़ें।
Q: बैच प्रोसेसिंग के दौरान मेमोरी लीक का सामना करने पर क्या करें?
A: सुनिश्चित करें कि प्रत्येक Annotator को बंद किया गया है (try‑with‑resources), JVM हीप की निगरानी करें, और बड़े बैच को छोटे समूहों में विभाजित करें।
अतिरिक्त संसाधन
- GroupDocs.Annotation Documentation
- API Reference Guide
- Download Latest Version
- Purchase License
- Free Trial Access
- Temporary License
- Support Forum
अंतिम अपडेट: 2026-10-16
Tested With: GroupDocs.Annotation 25.2 for Java
Author: 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");
}
}
}