PDF 주석 로드 Java: 완전한 GroupDocs Annotation 관리 가이드

<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;
import com.groupdocs.annotation.options.LoadOptions;
import java.util.List;

String inputFilePath = "YOUR_DOCUMENT_DIRECTORY/ANNOTATED_AREA_REPLIES_5.pdf";
LoadOptions loadOptions = new LoadOptions();
final Annotator annotator = new Annotator(inputFilePath, loadOptions);
List<AnnotationBase> annotations = annotator.get();
annotator.dispose();

String inputFilePath = "YOUR_DOCUMENT_DIRECTORY/ANNOTATED_AREA_REPLIES_5.pdf";
String outputPath = "YOUR_OUTPUT_DIRECTORY/RemovedRepliesOutput.pdf";

LoadOptions loadOptions = new LoadOptions();
final Annotator annotator = new Annotator(inputFilePath, loadOptions);
List<AnnotationBase> annotations = annotator.get();

for (int i = 0; i < annotations.get(0).getReplies().size(); i++) {
    if (annotations.get(0).getReplies().get(i).getUser().getName().toString().equals("Tom")) {
        annotations.get(0).getReplies().remove(i);
    }
}

annotator.update(annotations);
annotator.save(outputPath);
annotator.dispose();

// Remove replies older than 30 days
Date cutoffDate = new Date(System.currentTimeMillis() - (30L * 24 * 60 * 60 * 1000));

// Remove replies based on content patterns
if (reply.getText().toLowerCase().contains("draft") || reply.getText().toLowerCase().contains("test")) {
    // Remove test/draft replies
}

// Remove replies from specific user roles
if (reply.getUser().getRole().equals("temporary_reviewer")) {
    // Clean up temporary reviewer comments
}

// Process multiple documents
String[] documentPaths = getDocumentBatch();
for (String docPath : documentPaths) {
    cleanupPreliminaryReviews(docPath);
}

// Always Dispose Resources
try (Annotator annotator = new Annotator(inputFilePath)) {
    // Your annotation processing logic
} // Automatic resource cleanup

// Process Annotations in Batches
int batchSize = 100;
for (int i = 0; i < annotations.size(); i += batchSize) {
    List<AnnotationBase> batch = annotations.subList(i, Math.min(i + batchSize, annotations.size()));
    processBatch(batch);
}

// Use Streaming for Large Files
LoadOptions options = new LoadOptions();
options.setPreloadPageCount(1); // Load one page at a time

try {
    Annotator annotator = new Annotator(inputFilePath);
    // Success
} catch (Exception e) {
    if (e.getMessage().contains("path")) {
        System.err.println("Check file path: " + inputFilePath);
    } else if (e.getMessage().contains("permission")) {
        System.err.println("Verify file permissions");
    }
}

// Use try-with-resources
try (Annotator annotator = new Annotator(inputFilePath)) {
    // Process annotations
} // Automatic cleanup

// Limit annotation loading scope
LoadOptions options = new LoadOptions();
options.setLoadOnlyAnnotatedPages(true);

// Pagination for large annotation sets
int pageSize = 50;
for (int page = 0; page < totalPages; page++) {
    processAnnotationPage(annotations, page, pageSize);
}

// Refresh annotation collections after modifications
annotator.update(annotations);
annotations = annotator.get(); // Refresh the collection

// Validate file paths and user inputs
if (!isValidFilePath(inputFilePath)) {
    throw new IllegalArgumentException("Invalid file path");
}

if (!hasPermissionToModify(userId, documentId)) {
    throw new SecurityException("Insufficient permissions");
}

// Log annotation operations for compliance
auditLogger.info("User {} removed {} replies from document {}", 
    userId, removedCount, documentId);

// Simple annotation cache
Map<String, List<AnnotationBase>> annotationCache = new ConcurrentHashMap<>();

public List<AnnotationBase> getCachedAnnotations(String documentPath) {
    return annotationCache.computeIfAbsent(documentPath, path -> {
        try (Annotator annotator = new Annotator(path)) {
            return annotator.get();
        }
    });
}

CompletableFuture<Void> processDocumentAsync(String documentPath) {
    return CompletableFuture.runAsync(() -> {
        processAnnotations(documentPath);
    });
}

public boolean processWithRetry(String documentPath, int maxRetries) {
    for (int attempt = 1; attempt <= maxRetries; attempt++) {
        try {
            processAnnotations(documentPath);
            return true;
        } catch (Exception e) {
            if (attempt == maxRetries) {
                logger.error("Failed to process after {} attempts", maxRetries, e);
                return false;
            }
            try {
                Thread.sleep(1000 * attempt); // Exponential backoff
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
                return false;
            }
        }
    }
    return false;
}

@Test
public void testAnnotationLoading() {
    String testDocument = "test-documents/sample-with-annotations.pdf";
    
    try (Annotator annotator = new Annotator(testDocument)) {
        List<AnnotationBase> annotations = annotator.get();
        
        assertNotNull(annotations);
        assertTrue(annotations.size() > 0);
        
        // Verify annotation properties
        AnnotationBase firstAnnotation = annotations.get(0);
        assertNotNull(firstAnnotation.getAuthor());
        assertNotNull(firstAnnotation.getCreatedOn());
    }
}

LoadOptions options = new LoadOptions();
options.setPassword("your-document-password");
Annotator annotator = new Annotator(filePath, options);

Map<String, Integer> authorCounts = annotations.stream()
    .collect(Collectors.groupingBy(
        a -> a.getAuthor(), 
        Collectors.summingInt(a -> 1)
    ));