Bestandstype ophalen in Java – Documentmetadata extraheren met GroupDocs

Als je get file type java moet gebruiken en details wilt ophalen zoals paginatelling, grootte of auteurinformatie, ben je hier aan het juiste adres. Of je nu een document‑beheersysteem, een legal‑tech workflow of een eenvoudige batch‑organizer bouwt, het programmatisch extraheren van metadata bespaart uren handmatig werk en elimineert menselijke fouten. In deze tutorial lopen we alles door wat je moet weten om documentmetadata op te halen met GroupDocs.Comparison, van basisconfiguratie tot geavanceerde prestatie‑optimalisatie.

Snelle antwoorden

  • Wat betekent “java get file type”? Het betekent het programmatisch bepalen van het formaat van een document (PDF, DOCX, PPTX, enz.) in een Java‑applicatie.
  • Kan ik ook het PDF‑pagina‑aantal verkrijgen? Ja – dezelfde API‑aanroep retourneert info.getPageCount() voor PDF’s.
  • Heb ik een licentie nodig? Een gratis proefversie werkt voor evaluatie; een volledige licentie verwijdert watermerken en gebruiksbeperkingen.
  • Welke Java‑versie is vereist? JDK 8+ wordt ondersteund; JDK 11+ biedt betere geheugengebruik en prestaties.
  • Is dit geschikt voor grote batches? Absoluut – met goed resource‑beheer kun je duizenden bestanden gelijktijdig verwerken.

Wat is get file type java?

Get file type java is de handeling waarbij het formaat van een document direct uit de binaire inhoud wordt gedetecteerd met Java‑code. GroupDocs.Comparison leest de bestandsheader, bepaalt het MIME‑type en maakt het beschikbaar via het IDocumentInfo‑object, zodat je kunt handelen op basis van het formaat zonder te vertrouwen op bestandsextensies.

Waarom documentmetadata extraheren met GroupDocs?

GroupDocs.Comparison ondersteunt meer dan 100 invoer‑ en uitvoerformaten—inclusief PDF, DOCX, XLSX, PPTX, HTML en meer dan 30 afbeeldingsformaten—en kan multi‑honderd‑pagina‑bestanden verwerken zonder het volledige document in het geheugen te laden. Deze kwantificeerbare capaciteit maakt het ideaal voor high‑volume, enterprise‑grade pipelines. Het biedt bovendien snelle metadata‑extractie, wat zorgt voor lage latentie bij batchverwerking.

Vereisten en installatie

Wat je nodig hebt

  • JDK 8 of hoger (JDK 11+ aanbevolen voor verbeterde garbage‑collection)
  • Maven of Gradle voor dependency‑beheer
  • Een IDE zoals IntelliJ IDEA, Eclipse, of VS Code
  • Een GroupDocs.Comparison‑licentie voor productie (optioneel voor proefversie)

GroupDocs.Comparison toevoegen aan je project

Voeg de nieuwste Maven‑dependency toe aan je pom.xml:

<repositories>
   <repository>
      <id>repository.groupdocs.com</id>
      <name>GroupDocs Repository</name>
      <url>https://releases.groupdocs.com/comparison/java/</url>
   </repository>
</repositories>
<dependencies>
   <dependency>
      <groupId>com.groupdocs</groupId>
      <artifactId>groupdocs-comparison</artifactId>
      <version>25.2</version>
   </dependency>
</dependencies>

Pro Tip: Verwijs altijd naar de nieuwste versie op de GroupDocs releases page om te profiteren van beveiligingspatches en nieuwe format‑ondersteuning.

Je licentie verkrijgen (Sla dit niet over!)

  1. Free Trial – download van de GroupDocs Downloads pagina.
  2. Temporary License – vraag er een aan voor ontwikkeling op de Temporary License Page.
  3. Full License – koop een onbeperkte productie‑licentie via de Purchase Page.

Basisconfiguratie en initialisatie

De Comparer‑klasse is het toegangspunt voor alle documentbewerkingen in GroupDocs.Comparison. Ze implementeert AutoCloseable, dus een try‑with‑resources‑blok garandeert correcte opruiming.

import com.groupdocs.comparison.Comparer;

public class DocumentMetadataExtractor {
    public static void main(String[] args) {
        String sourceFilePath = "YOUR_DOCUMENT_DIRECTORY/sample.docx";
        
        try (Comparer comparer = new Comparer(sourceFilePath)) {
            System.out.println("GroupDocs.Comparison is ready to use!");
            // We'll add metadata extraction code here
        } catch (Exception e) {
            System.err.println("Error initializing GroupDocs: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Hoe bestandstype extraheren met GroupDocs?

getDocumentInfo() retourneert een IDocumentInfo‑instantie met metadata over het geladen document. Laad het document met Comparer en roep getDocumentInfo() aan. Het IDocumentInfo‑object levert direct het bestandsformaat, paginatelling, grootte en andere eigenschappen. Deze één‑regelige aanroep levert alles wat je nodig hebt voor get file type java. De methode werkt zowel voor lokale bestanden als streams, waardoor hij veelzijdig is voor verschillende opslagscenario’s.

import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.result.IDocumentInfo;

public class FilePathMetadataExtraction {
    public static void extractMetadataFromPath(String filePath) {
        try (Comparer comparer = new Comparer(filePath)) {
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            
            System.out.printf("
File Analysis Results:
File type: %s
Number of pages: %d
Document size: %d bytes (%.2f KB)%n", 
                info.getFileType().getFileFormat(), 
                info.getPageCount(), 
                info.getSize(),
                info.getSize() / 1024.0);
        } catch (Exception e) {
            System.err.println("Failed to extract metadata: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        String documentPath = "YOUR_DOCUMENT_DIRECTORY/sample.pdf";
        extractMetadataFromPath(documentPath);
    }
}

Wanneer deze aanpak te gebruiken

  • Bestanden worden lokaal op dezelfde server opgeslagen.
  • Je hebt een snelle, low‑overhead metadata‑lezing nodig.
  • Batch‑taken draaien op een bestandssysteem waar pad‑toegang goedkoop is.

Hoe PDF‑pagina‑aantal verkrijgen met GroupDocs?

getPageCount() retourneert het totale aantal pagina’s in het document. De IDocumentInfo.getPageCount()‑methode geeft het exacte aantal pagina’s voor PDF, Word en andere gepagineerde formaten. Het werkt zonder het volledige document te openen, waardoor het geheugengebruik laag blijft. Dit stelt ontwikkelaars in staat om snel de documentgrootte te beoordelen voordat intensieve verwerking of conversietaken worden uitgevoerd.

import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.result.IDocumentInfo;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;

public class InputStreamMetadataExtraction {
    public static void extractMetadataFromStream(String filePath) {
        try (InputStream sourceStream = new FileInputStream(filePath);
             Comparer comparer = new Comparer(sourceStream)) {
            
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            
            System.out.println("Document Metadata Analysis:");
            System.out.println("==========================");
            System.out.printf("File Format: %s%n", info.getFileType().getFileFormat());
            System.out.printf("Total Pages: %d%n", info.getPageCount());
            System.out.printf("File Size: %d bytes%n", info.getSize());
            System.out.printf("Size (Human Readable): %s%n", formatFileSize(info.getSize()));
            
        } catch (IOException e) {
            System.err.println("IO Error: " + e.getMessage());
        } catch (Exception e) {
            System.err.println("Metadata extraction failed: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    // Helper method to make file sizes more readable
    private static String formatFileSize(long size) {
        if (size < 1024) return size + " bytes";
        if (size < 1024 * 1024) return String.format("%.2f KB", size / 1024.0);
        if (size < 1024 * 1024 * 1024) return String.format("%.2f MB", size / (1024.0 * 1024.0));
        return String.format("%.2f GB", size / (1024.0 * 1024.0 * 1024.0));
    }
    
    public static void main(String[] args) {
        String documentPath = "YOUR_DOCUMENT_DIRECTORY/report.xlsx";
        extractMetadataFromStream(documentPath);
    }
}

Waarom paginatelling belangrijk is

  • Juridische teams verifiëren dat contracten de vereiste lengte hebben.
  • Publicatie‑pipelines handhaven paginalimieten.
  • Analyse‑dashboards tonen trends in documentgrootte.

Hoe documentmetadata lezen vanuit InputStream?

Wanneer documenten zich in databases, cloud‑buckets of via HTTP bevinden, kun je een InputStream direct aan Comparer voeren. Dit voorkomt tijdelijke bestanden en vermindert I/O‑latentie. Het streamen van de inhoud minimaliseert ook schijfgebruik en verbetert de doorvoer in high‑volume ingest‑pipelines.

public class DocumentCatalogSystem {
    public void catalogDocument(String filePath) {
        try (Comparer comparer = new Comparer(filePath)) {
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            
            // Store in database or index for search
            DocumentRecord record = new DocumentRecord();
            record.setFileType(info.getFileType().getFileFormat());
            record.setPageCount(info.getPageCount());
            record.setFileSize(info.getSize());
            record.setFilePath(filePath);
            
            // Save to your database here
            saveDocumentRecord(record);
            
        } catch (Exception e) {
            logError("Failed to catalog document: " + filePath, e);
        }
    }
}

Voordelen van InputStream-afhandeling

  • Database storage – lees BLOB‑s zonder naar schijf te schrijven.
  • Network sources – stream bestanden van S3, Azure Blob of REST‑endpoints.
  • Security – beperk blootstelling van het bestandssysteem door data in het geheugen te houden.
  • Scalability – combineer met Java NIO‑kanalen voor non‑blocking verwerking.

Praktische toepassingen en use‑cases

1. Integratie met Content Management Systeem

Tag geüploade bestanden automatisch met hun formaat, paginatelling en grootte zodat het CMS ze correct kan sorteren en weergeven.

public class LegalDocumentValidator {
    public boolean validateSubmission(String documentPath) {
        try (Comparer comparer = new Comparer(documentPath)) {
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            
            // Check if document meets legal requirements
            boolean isValidFormat = isAcceptedFormat(info.getFileType().getFileFormat());
            boolean hasValidPageCount = info.getPageCount() > 0 && info.getPageCount() <= 50;
            boolean isValidSize = info.getSize() <= 10 * 1024 * 1024; // 10MB max
            
            return isValidFormat && hasValidPageCount && isValidSize;
            
        } catch (Exception e) {
            return false; // Invalid if we can't process it
        }
    }
    
    private boolean isAcceptedFormat(String format) {
        return Arrays.asList("PDF", "DOCX", "DOC").contains(format.toUpperCase());
    }
}

2. Documentvalidatie voor juridische systemen

Valideer dat elk ingediend contract een PDF is en minimaal het vereiste aantal pagina’s bevat voordat het de beoordelingsworkflow binnenkomt.

public class BatchDocumentProcessor {
    public void processDocumentDirectory(String directoryPath) {
        File directory = new File(directoryPath);
        File[] files = directory.listFiles((dir, name) -> 
            name.toLowerCase().endsWith(".pdf") || 
            name.toLowerCase().endsWith(".docx") ||
            name.toLowerCase().endsWith(".xlsx"));
        
        if (files == null) {
            System.out.println("No documents found in directory");
            return;
        }
        
        System.out.println("Processing " + files.length + " documents...");
        
        for (File file : files) {
            processDocument(file.getAbsolutePath());
        }
    }
    
    private void processDocument(String filePath) {
        try (Comparer comparer = new Comparer(filePath)) {
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            
            System.out.printf("%s: %s, %d pages, %s%n", 
                new File(filePath).getName(),
                info.getFileType().getFileFormat(),
                info.getPageCount(),
                formatFileSize(info.getSize()));
                
        } catch (Exception e) {
            System.err.println("Error processing " + filePath + ": " + e.getMessage());
        }
    }
}

3. Batch documentverwerking

Voer een nachtelijke taak uit die een gedeelde map scant, metadata extraheert en de resultaten naar een relationele database schrijft voor rapportage.

java.io.FileNotFoundException: YOUR_DOCUMENT_DIRECTORY/document.pdf (No such file or directory)

Veelvoorkomende problemen en probleemoplossing

Probleem 1: FileNotFoundException

Direct answer: Controleer of het pad dat je aan Comparer doorgeeft correct is, gebruik absolute paden, en zorg dat het Java‑proces leesrechten heeft.
Solution: Controleer de OS‑bestandstoestemmingen en geef de voorkeur aan Paths.get(...).toAbsolutePath() om verwarring met relatieve paden te vermijden.

public static boolean processDocumentSafely(String filePath) {
    File file = new File(filePath);
    
    if (!file.exists()) {
        System.err.println("File not found: " + filePath);
        return false;
    }
    
    if (!file.canRead()) {
        System.err.println("Cannot read file: " + filePath);
        return false;
    }
    
    try (Comparer comparer = new Comparer(filePath)) {
        // Your metadata extraction code here
        return true;
    } catch (Exception e) {
        System.err.println("Processing failed: " + e.getMessage());
        return false;
    }
}

Probleem 2: Niet‑ondersteund bestandsformaat

Direct answer: Roep vóór verwerking Comparer.isSupported(fileExtension) aan om te bevestigen dat het formaat op de ondersteunde lijst staat.
Solution: isSupported() controleert of de opgegeven bestandsextensie behoort tot de formaten die GroupDocs ondersteunt. Als het formaat niet wordt ondersteund, converteer het dan vooraf of informeer de gebruiker.

public static boolean isSupportedFormat(String filePath) {
    String extension = filePath.substring(filePath.lastIndexOf('.') + 1).toLowerCase();
    Set<String> supportedFormats = Set.of(
        "pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", 
        "txt", "rtf", "odt", "ods", "odp"
    );
    return supportedFormats.contains(extension);
}

Probleem 3: Geheugenproblemen met grote bestanden

Direct answer: Gebruik de streaming‑API (Comparer met InputStream) en schakel Comparer.setLoadOptions(LoadOptions.memoryOptimized()) in om de geheugengebruik onder 100 MB te houden, zelfs voor PDF’s van 500 pagina’s.
Solution: LoadOptions.memoryOptimized() configureert de loader om minimaal geheugen te gebruiken bij het lezen van grote bestanden. Verwerk bestanden in kleinere delen of vergroot de JVM‑heap (-Xmx2g) indien nodig.

public static void processLargeDocument(String filePath) {
    // Set JVM options: -Xmx2g -XX:+UseG1GC
    
    System.gc(); // Suggest garbage collection before processing
    
    try (Comparer comparer = new Comparer(filePath)) {
        IDocumentInfo info = comparer.getSource().getDocumentInfo();
        
        if (info.getSize() > 100 * 1024 * 1024) { // 100 MB
            System.out.println("Warning: Processing large file (" + 
                formatFileSize(info.getSize()) + ")");
        }
        
        // Process document
        
    } catch (OutOfMemoryError e) {
        System.err.println("File too large to process: " + filePath);
        // Consider splitting or using a streaming approach
    }
}

Probleem 4: Licentie‑gerelateerde fouten

Direct answer: Laad het licentiebestand één keer bij het opstarten van de applicatie met License license = new License(); license.setLicense("license_path");. Dit voorkomt herhaalde licentiecontroles die prestatie‑penalties veroorzaken.
Solution: License laadt en past een GroupDocs‑licentie toe op de API. Bewaar de licentie op een veilige locatie en verwijs ernaar via een omgevingsvariabele.

public class LicenseManager {
    private static boolean licenseSet = false;
    
    public static void setLicense() {
        if (!licenseSet) {
            try {
                License license = new License();
                license.setLicense("path/to/your/license.lic");
                licenseSet = true;
                System.out.println("License applied successfully");
            } catch (Exception e) {
                System.err.println("License error: " + e.getMessage());
                System.out.println("Running in evaluation mode");
            }
        }
    }
}

Tips voor prestatie‑optimalisatie

1. Resourcebeheer

Herbruik een enkele Comparer‑instantie voor meerdere bestanden wanneer mogelijk, en sluit deze altijd af met try‑with‑resources.

public class OptimizedDocumentProcessor {
    private static final int MAX_CONCURRENT_PROCESSES = Runtime.getRuntime().availableProcessors();
    private ExecutorService executorService = Executors.newFixedThreadPool(MAX_CONCURRENT_PROCESSES);
    
    public void processDocumentsConcurrently(List<String> filePaths) {
        List<Future<DocumentMetadata>> futures = new ArrayList<>();
        
        for (String filePath : filePaths) {
            Future<DocumentMetadata> future = executorService.submit(() -> {
                return extractMetadata(filePath);
            });
            futures.add(future);
        }
        
        // Collect results
        for (Future<DocumentMetadata> future : futures) {
            try {
                DocumentMetadata metadata = future.get(30, TimeUnit.SECONDS);
                processMetadata(metadata);
            } catch (TimeoutException e) {
                System.err.println("Document processing timed out");
            }
        }
    }
}

2. Caching‑strategie

Cache IDocumentInfo‑resultaten voor bestanden die herhaaldelijk worden verwerkt. Een eenvoudige ConcurrentHashMap<String, DocumentInfo> vermindert dubbele I/O tot wel 70 % in high‑throughput‑scenario’s.

public class CachedMetadataExtractor {
    private static final Map<String, DocumentMetadata> metadataCache = new ConcurrentHashMap<>();
    
    public DocumentMetadata getDocumentMetadata(String filePath) {
        File file = new File(filePath);
        String cacheKey = filePath + "_" + file.lastModified();
        
        return metadataCache.computeIfAbsent(cacheKey, key -> {
            return extractMetadataInternal(filePath);
        });
    }
    
    private DocumentMetadata extractMetadataInternal(String filePath) {
        try (Comparer comparer = new Comparer(filePath)) {
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            return new DocumentMetadata(
                info.getFileType().getFileFormat(),
                info.getPageCount(),
                info.getSize()
            );
        } catch (Exception e) {
            throw new RuntimeException("Failed to extract metadata", e);
        }
    }
}

3. Geheugenefficiënte verwerking

Schakel LoadOptions.memoryOptimized() in en vermijd het laden van het volledige document wanneer je alleen metadata nodig hebt. Dit verlaagt het RAM‑gebruik met ongeveer 80 % voor grote PDF’s.

public class MemoryEfficientProcessor {
    public void processLargeDirectory(String directoryPath) {
        try (Stream<Path> paths = Files.walk(Paths.get(directoryPath))) {
            paths.filter(Files::isRegularFile)
                 .filter(path -> isSupportedFormat(path.toString()))
                 .forEach(path -> {
                     processDocument(path.toString());
                     System.gc(); // Suggest cleanup after each document
                 });
        } catch (IOException e) {
            System.err.println("Error accessing directory: " + e.getMessage());
        }
    }
}

Geavanceerde use‑cases

Een document‑analyse‑dashboard bouwen

Verzamel metadata van duizenden bestanden, sla ze op in Elasticsearch en visualiseer trends zoals gemiddelde paginatelling per formaat, totale opslag per type en meest voorkomende bestandsextensies.

public class DocumentAnalytics {
    public Map<String, Integer> getFormatDistribution(List<String> filePaths) {
        Map<String, Integer> formatCounts = new HashMap<>();
        
        for (String filePath : filePaths) {
            try (Comparer comparer = new Comparer(filePath)) {
                IDocumentInfo info = comparer.getSource().getDocumentInfo();
                String format = info.getFileType().getFileFormat();
                formatCounts.merge(format, 1, Integer::sum);
            } catch (Exception e) {
                formatCounts.merge("ERROR", 1, Integer::sum);
            }
        }
        
        return formatCounts;
    }
    
    public long getTotalDocumentSize(List<String> filePaths) {
        return filePaths.stream()
                .mapToLong(this::getDocumentSize)
                .sum();
    }
    
    private long getDocumentSize(String filePath) {
        try (Comparer comparer = new Comparer(filePath)) {
            return comparer.getSource().getDocumentInfo().getSize();
        } catch (Exception e) {
            return 0;
        }
    }
}

Best practices en pro‑tips

1. Altijd try‑with‑resources gebruiken

Zorgt ervoor dat native resources direct worden vrijgegeven, waardoor bestandsvergrendelingen en geheugenlekken worden voorkomen.

// Good - automatic resource management
try (Comparer comparer = new Comparer(filePath)) {
    // Your code here
} catch (Exception e) {
    // Handle errors
}

// Avoid - manual resource management (error‑prone)
Comparer comparer = new Comparer(filePath);
// If exception occurs here, resources might not be cleaned up
comparer.close();

2. Implementeer juiste foutafhandeling

Wikkel metadata‑extractie in een try‑catch‑blok dat de bestandsnaam en de specifieke uitzondering logt, en ga vervolgens door met de volgende file.

public class RobustDocumentProcessor {
    public Optional<DocumentMetadata> extractMetadata(String filePath) {
        try (Comparer comparer = new Comparer(filePath)) {
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            return Optional.of(new DocumentMetadata(info));
        } catch (Exception e) {
            logError("Failed to process: " + filePath, e);
            return Optional.empty();
        }
    }
}

3. Valideer invoerparameters

Controleer op null‑streams, bestanden met lengte nul en niet‑ondersteunde extensies voordat je de API aanroept.

public void processDocument(String filePath) {
    Objects.requireNonNull(filePath, "File path cannot be null");
    
    if (filePath.trim().isEmpty()) {
        throw new IllegalArgumentException("File path cannot be empty");
    }
    
    if (!new File(filePath).exists()) {
        throw new IllegalArgumentException("File does not exist: " + filePath);
    }
    
    // Process the document
}

4. Met wachtwoord beveiligde documenten

Geef het wachtwoord door aan Comparer via LoadOptions.setPassword("yourPassword") om versleutelde PDF’s te ontgrendelen vóór het extraheren van metadata.

LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your-password");
try (Comparer comparer = new Comparer(filePath, loadOptions)) {
    // Extract metadata from password‑protected document
}

5. Cloudopslag (bijv. AWS S3)

Gebruik de AWS SDK om een S3ObjectInputStream te verkrijgen en deze direct in Comparer te voeden. Dit elimineert de noodzaak voor tijdelijke lokale kopieën.

// Example with AWS S3
S3Object object = s3Client.getObject("bucket-name", "document-key");
try (InputStream stream = object.getObjectContent();
     Comparer comparer = new Comparer(stream)) {
    // Extract metadata
}

Veelgestelde vragen

Q: Kan ik dit gebruiken in een commerciële applicatie?
A: Ja, zodra je een geldige GroupDocs.Comparison‑licentie toepast, wordt de bibliotheek volledig ondersteund voor commerciële implementaties.

Q: Werkt de API met met wachtwoord beveiligde PDF’s?
A: Absoluut. Geef het wachtwoord door via LoadOptions.setPassword() voordat je getDocumentInfo() aanroept.

Q: Welke Java‑versies worden officieel ondersteund?
A: GroupDocs.Comparison ondersteunt JDK 8, 11, 17 en latere LTS‑releases.

Q: Hoe gaat de bibliotheek om met extreem grote bestanden (bijv. >1 GB)?
A: Door de streaming‑API en memory‑optimized load‑options te gebruiken, kun je multi‑gigabyte bestanden verwerken zonder ze volledig in RAM te laden.

Q: Is er een manier om bestanden parallel te batch‑verwerken?
A: Ja—combineer Java’s ExecutorService met thread‑safe instanties van Comparer (of maak een pool van comparers) om lineaire schaalbaarheid te bereiken op multi‑core servers.

Conclusie en volgende stappen

Je hebt nu een volledige, productie‑klare aanpak voor get file type java en het extraheren van alle relevante documentmetadata met GroupDocs.Comparison. Je kunt:

  1. Formaat, paginatelling, grootte en aangepaste eigenschappen ophalen met één API‑aanroep.
  2. Kiezen tussen pad‑gebaseerde of stream‑gebaseerde extractie, afhankelijk van je opslagarchitectuur.
  3. Caching, streaming en geheugen‑optimalisatietechnieken toepassen om te schalen naar duizenden documenten per dag.

Bekijk vervolgens GroupDocs.Metadata voor diepere auteur‑ en revisie‑gegevens, of integreer de metadata‑extractor in een REST‑service die een doorzoekbare documentcatalogus aandrijft.

Last Updated: 2026-05-21
Tested With: GroupDocs.Comparison 25.2
Author: GroupDocs

Bronnen voor verdere studie:

Gerelateerde tutorials