<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 java.io.IOException;

String inputFile = "YOUR_DOCUMENT_DIRECTORY/document.pdf"; // Point this to your test file

try (final Annotator annotator = new Annotator(inputFile)) {
    // Your metadata extraction code goes here
    // The try-with-resources ensures proper cleanup
} catch (IOException e) {
    System.err.println("Couldn't access the document: " + e.getMessage());
    // Handle the error appropriately for your use case
}

import com.groupdocs.annotation.IDocumentInfo;

try (final Annotator annotator = new Annotator(inputFile)) {
    IDocumentInfo info = null;
    try {
        // This is where the magic happens
        info = annotator.getDocument().getDocumentInfo();
        
        if (info != null) {
            System.out.println("Number of Pages: " + info.getPageCount());
            System.out.println("File Type: " + info.getFileType());
            System.out.println("Size: " + info.getSize() + " bytes");
            
            // Convert bytes to more readable format
            double sizeInMB = info.getSize() / (1024.0 * 1024.0);
            System.out.printf("Size: %.2f MB%n", sizeInMB);
        } else {
            System.out.println("Couldn't extract document information");
        }
    } catch (IOException e) {
        System.err.println("Error extracting metadata: " + e.getMessage());
    }
}

String baseDir = System.getProperty("user.dir");
String inputFile = baseDir + "/documents/sample.pdf";

try {
    // metadata extraction code
} catch (IOException e) {
    logger.error("Cannot access file: " + inputFile, e);
} catch (Exception e) {
    logger.error("Unexpected error processing document", e);
}

List<String> documentPaths = Arrays.asList("doc1.pdf", "doc2.docx", "doc3.xlsx");

for (String path : documentPaths) {
    try (final Annotator annotator = new Annotator(path)) {
        IDocumentInfo info = annotator.getDocument().getDocumentInfo();
        // Process info immediately
        processDocumentInfo(path, info);
    } catch (Exception e) {
        // Log error but continue with next document
        logger.warn("Failed to process " + path + ": " + e.getMessage());
    }
}

Map<String, IDocumentInfo> metadataCache = new ConcurrentHashMap<>();

public IDocumentInfo getDocumentInfo(String filePath) {
    return metadataCache.computeIfAbsent(filePath, path -> {
        try (final Annotator annotator = new Annotator(path)) {
            return annotator.getDocument().getDocumentInfo();
        } catch (Exception e) {
            logger.error("Failed to extract metadata for " + path, e);
            return null;
        }
    });
}

public class DocumentProcessor {
    public DocumentMetadata processUploadedDocument(String filePath) {
        try (final Annotator annotator = new Annotator(filePath)) {
            IDocumentInfo info = annotator.getDocument().getDocumentInfo();
            
            return new DocumentMetadata.Builder()
                .pageCount(info.getPageCount())
                .fileType(info.getFileType())
                .sizeInBytes(info.getSize())
                .processedDate(LocalDateTime.now())
                .build();
        } catch (Exception e) {
            throw new DocumentProcessingException("Failed to process document", e);
        }
    }
}

public void organizeDocumentsByType(List<String> filePaths) {
    for (String path : filePaths) {
        try (final Annotator annotator = new Annotator(path)) {
            IDocumentInfo info = annotator.getDocument().getDocumentInfo();
            String destinationFolder = "organized/" + info.getFileType().toLowerCase();
            
            Files.createDirectories(Paths.get(destinationFolder));
            Files.move(Paths.get(path), 
                      Paths.get(destinationFolder, Paths.get(path).getFileName().toString()));
        } catch (Exception e) {
            logger.warn("Failed to organize file: " + path, e);
        }
    }
}

public Optional<DocumentMetadata> extractMetadata(String filePath) {
    try (final Annotator annotator = new Annotator(filePath)) {
        IDocumentInfo info = annotator.getDocument().getDocumentInfo();
        return Optional.of(new DocumentMetadata(info));
    } catch (IOException e) {
        logger.error("IO error processing " + filePath, e);
        return Optional.empty();
    } catch (Exception e) {
        logger.error("Unexpected error processing " + filePath, e);
        return Optional.empty();
    }
}

logger.info("Processing document: {} (Size: {} bytes)", filePath, fileSize);
long startTime = System.currentTimeMillis();

// ... metadata extraction code ...

long processingTime = System.currentTimeMillis() - startTime;
logger.info("Processed {} in {}ms", filePath, processingTime);

# application.properties
document.processing.max-file-size=50MB
document.processing.timeout=30s
document.processing.batch-size=100