Java Get File Type – Εξαγωγή Μεταδεδομένων Εγγράφου μέσω GroupDocs

Κάποτε βρέθηκες να κοιτάς έναν φάκελο γεμάτο έγγραφα, αναρωτιέσαι ποια είναι PDF, πόσες σελίδες περιέχουν ή ποιο είναι το μέγεθός τους; Αν εργάζεσαι με επεξεργασία εγγράφων σε Java, πιθανότατα έχεις αντιμετωπίσει αυτή την πρόκληση. Είτε χτίζεις σύστημα διαχείρισης περιεχομένου, αυτοματοποιείς ροές εργασίας εγγράφων, είτε απλώς χρειάζεσαι να οργανώσεις αρχεία προγραμματιστικά, η εξαγωγή μεταδεδομένων εγγράφου είναι ένας καθοριστικός παράγοντας. Σε αυτόν τον οδηγό θα μάθεις πώς να java get file type και να ανακτήσεις άλλες ιδιότητες όπως ο αριθμός σελίδων χρησιμοποιώντας το GroupDocs.Comparison.

Quick Answers

  • Τι σημαίνει “java get file type”; Αναφέρεται στην ανάκτηση της μορφής αρχείου (PDF, DOCX, κ.λπ.) ενός εγγράφου προγραμματιστικά σε Java.
  • Μπορώ επίσης να λάβω τον αριθμό σελίδων PDF; Ναι – με το GroupDocs μπορείς εύκολα java pdf page count.
  • Χρειάζεται άδεια; Μια δωρεάν δοκιμή λειτουργεί για αξιολόγηση· μια πλήρης άδεια αφαιρεί τα υδατογραφήματα και τους περιορισμούς.
  • Ποια έκδοση Java απαιτείται; Υποστηρίζεται JDK 8+, αλλά το JDK 11+ προσφέρει καλύτερη απόδοση.
  • Είναι κατάλληλο για μεγάλες παρτίδες; Ναι – με σωστή διαχείριση πόρων και ταυτόχρονη εκτέλεση μπορείς να επεξεργαστείς χιλιάδες αρχεία.

Why Extract Document Metadata in Java?

Πριν βουτήξουμε στον κώδικα, ας δούμε γιατί η εξαγωγή μεταδεδομένων εγγράφου έχει σημασία σε πραγματικές εφαρμογές:

Common Business Scenarios:

  • Document Management Systems: Αυτόματη κατηγοριοποίηση και οργάνωση ανεβασμένων αρχείων
  • Legal Software: Επαλήθευση της πληρότητας του εγγράφου ελέγχοντας τον αριθμό σελίδων
  • Educational Platforms: Επικύρωση ότι οι υποβολές των φοιτητών πληρούν τις απαιτήσεις μορφής
  • Financial Applications: Διασφάλιση ότι οι αναφορές συμμορφώνονται με κανονιστικά πρότυπα
  • Content Auditing: Ανάλυση συλλογών εγγράφων για συμμόρφωση ή έλεγχο ποιότητας

Η δυνατότητα προγραμματιστικής εξαγωγής μεταδεδομένων εξοικονομεί αμέτρητες ώρες χειροκίνητης εργασίας και μειώνει τα ανθρώπινα λάθη. Επιπλέον, με το GroupDocs.Comparison λαμβάνεις υποστήριξη για 100+ μορφές αρχείων – από τις κοινές όπως PDF και DOCX έως εξειδικευμένες μορφές.

What You’ll Learn in This Tutorial

Στο τέλος αυτού του οδηγού, θα μπορείς να:

  • Ρυθμίσεις το GroupDocs.Comparison στο Java project σου
  • Εξάγεις μεταδεδομένα εγγράφου χρησιμοποιώντας τόσο διαδρομές αρχείων όσο και InputStreams
  • Διαχειριστείς συνήθεις σφάλματα και ειδικές περιπτώσεις
  • Βελτιστοποιήσεις την απόδοση για επεξεργασία μεγάλου όγκου εγγράφων
  • Εφαρμόσεις αυτές τις τεχνικές σε πραγματικά σενάρια

Prerequisites and Setup

What You’ll Need

Πριν ξεκινήσεις τον κώδικα, βεβαιώσου ότι έχεις:

  • Java Development Kit (JDK) 8 ή νεότερο (συνιστάται JDK 11+ για καλύτερη απόδοση)
  • Maven ή Gradle για διαχείριση εξαρτήσεων
  • Το αγαπημένο σου IDE (IntelliJ IDEA, Eclipse ή VS Code λειτουργούν άψογα)
  • Βασικές γνώσεις Java – αν μπορείς να γράψεις ένα for loop, είσαι έτοιμος!

Adding GroupDocs.Comparison to Your Project

Ο πιο εύκολος τρόπος για να ξεκινήσεις είναι μέσω Maven. Πρόσθεσε αυτό στο 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: Πάντα χρησιμοποίησε την πιο πρόσφατη έκδοση για τα καλύτερα χαρακτηριστικά και ενημερώσεις ασφαλείας. Έλεγξε τη GroupDocs releases page για την πιο τρέχουσα έκδοση.

Getting Your License (Don’t Skip This!)

Παρόλο που το GroupDocs.Comparison λειτουργεί χωρίς άδεια για αξιολόγηση, θα δεις υδατογραφήματα στα επεξεργασμένα έγγραφα. Να πώς να αποκτήσεις έγκυρη άδεια:

  1. Free Trial: Ιδανικό για δοκιμές – κατέβασε από το GroupDocs Downloads
  2. Temporary License: Κατάλληλο για ανάπτυξη – απόκτησέ το στη Temporary License Page
  3. Full License: Για παραγωγική χρήση – διαθέσιμο στη Purchase Page

Basic Setup and Initialization

Ας ξεκινήσουμε με ένα απλό παράδειγμα για να βεβαιωθούμε ότι όλα λειτουργούν:

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();
        }
    }
}

Αυτή η βασική ρύθμιση δημιουργεί ένα αντικείμενο Comparer – το κύριο εργαλείο σου για εργασία με έγγραφα. Η δήλωση try‑with‑resources εξασφαλίζει σωστό καθαρισμό των πόρων.

How to java get file type from a document

Χρησιμοποιώντας το API του Comparer, μπορείς εύκολα java get file type μαζί με άλλες ιδιότητες όπως αριθμός σελίδων και μέγεθος αρχείου. Παρακάτω δύο κοινές προσεγγίσεις.

Method 1: Extract Document Metadata Using File Paths

Αυτή είναι η πιο απλή προσέγγιση, ιδανική όταν εργάζεσαι με τοπικά αρχεία ή έχεις άμεση πρόσβαση σε διαδρομές αρχείων.

Step‑by‑Step Implementation

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

What’s happening here?

  1. Comparer Initialization – δημιουργούμε ένα αντικείμενο Comparer με τη διαδρομή του αρχείου.
  2. Info Extraction – το getDocumentInfo() ανακτά όλα τα διαθέσιμα μεταδεδομένα, επιτρέποντάς σου java get file type, page count και size.
  3. Data Display – μορφοποιούμε και εμφανίζουμε τις βασικές πληροφορίες.

When to Use This Method

Η εξαγωγή μέσω διαδρομής αρχείου είναι ιδανική όταν:

  • Εργάζεσαι με τοπικά αρχεία
  • Τα αρχεία αποθηκεύονται σε προσβάσιμους φακέλους
  • Χρειάζεσαι απλή, άμεση εξαγωγή μεταδεδομένων
  • Η απόδοση δεν είναι κρίσιμη (μικρού‑μέσου όγκου αρχεία)

How to java pdf page count using GroupDocs

Αν το κύριο ενδιαφέρον σου είναι ο αριθμός σελίδων σε PDF, το ίδιο αντικείμενο IDocumentInfo παρέχει ακριβή μέτρηση. Το παραπάνω παράδειγμα δείχνει ήδη το info.getPageCount(), που είναι το java pdf page count που ψάχνεις.

Method 2: Extract Document Metadata Using InputStreams

Τα InputStreams είναι εξαιρετικά ισχυρά για διαχείριση εγγράφων από διάφορες πηγές – βάσεις δεδομένων, ροές δικτύου ή όταν χρειάζεσαι μεγαλύτερο έλεγχο στην επεξεργασία αρχείων.

Step‑by‑Step Implementation

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

Why Use InputStreams?

Τα InputStreams ξεχωρίζουν όταν:

  • Database Storage: Τα έγγραφα αποθηκεύονται ως BLOBs
  • Network Sources: Τα αρχεία έρχονται μέσω HTTP, FTP ή αποθήκευσης cloud
  • Memory Management: Χρειάζεσαι λεπτομερή έλεγχο της χρήσης πόρων
  • Security: Θέλεις να περιορίσεις την άμεση πρόσβαση στο σύστημα αρχείων
  • Scalability: Η ροή ταιριάζει καλά με σύνδεση pooling και ασύγχρονη επεξεργασία

Real‑World Applications and Use Cases

1. Content Management System Integration

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

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());
    }
}

3. Batch Document Processing

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());
        }
    }
}

Common Issues and Troubleshooting

Ακόμη και με τον καλύτερο κώδικα, μπορεί να προκύψουν προβλήματα. Εδώ είναι τα πιο συχνά ζητήματα και πώς να τα λύσεις:

Issue 1: FileNotFoundException

Problem

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

Solution – επαλήθευσε τη διαδρομή, χρησιμοποίησε απόλυτες διαδρομές και βεβαιώσου ότι έχεις δικαιώματα ανάγνωσης:

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;
    }
}

Issue 2: Unsupported File Format

Problem – προσπάθεια επεξεργασίας μορφής που δεν υποστηρίζεται από το GroupDocs.

Solution – έλεγξε πρώτα τις υποστηριζόμενες επεκτάσεις:

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

Issue 3: Memory Issues with Large Files

Problem – OutOfMemoryError κατά την επεξεργασία πολύ μεγάλων εγγράφων.

Solution – διαχειρίσου τη μνήμη προληπτικά:

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
    }
}

Issue 4: License‑Related Errors

Problem – εμφανίζονται υδατογραφήματα ή ρίχνεται εξαίρεση άδειας.

Solution – φόρτωσε την άδεια μία φορά κατά την εκκίνηση της εφαρμογής:

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");
            }
        }
    }
}

Performance Optimization Tips

Όταν επεξεργάζεσαι πολλά έγγραφα ή μεγάλα αρχεία, η απόδοση γίνεται κρίσιμη. Ακολουθούν αποδεδειγμένες στρατηγικές:

1. Resource Management

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 Strategy

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. Memory‑Efficient Processing

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());
        }
    }
}

Advanced Use Cases

Building a Document Analytics Dashboard

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 and Pro Tips

1. Always Use Try‑With‑Resources

// 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. Implement Proper Error Handling

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. Validate Input Parameters

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. Password‑Protected Documents

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

5. Cloud Storage (e.g., AWS S3)

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

Conclusion and Next Steps

Συγχαρητήρια! Τώρα έχεις κατακτήσει το java get file type και την εξαγωγή σχετικών μεταδεδομένων σε Java χρησιμοποιώντας το GroupDocs.Comparison. Μπορείς να ανακτήσεις τύπους αρχείων, αριθμούς σελίδων (συμπεριλαμβανομένου του java pdf page count) και μεγέθη από σχεδόν οποιαδήποτε μορφή εγγράφου, να διαχειρίζεσαι σφάλματα με ευγένεια και να βελτιστοποιείς την απόδοση για λειτουργίες μεγάλης κλίμακας.

Key Takeaways

  • Δύο μέθοδοι εξαγωγής: διαδρομές αρχείων για απλότητα, InputStreams για ευελιξία
  • Ισχυρή διαχείριση σφαλμάτων προστατεύει την εφαρμογή σου από κατεστραμμένα αρχεία
  • Τεχνικές απόδοσης—caching, concurrency, streaming—κλιμακώνουν τη λύση
  • Παραδείγματα πραγματικού κόσμου δείχνουν πώς να ενσωματώσεις τα μεταδεδομένα σε CMS, επαλήθευση και pipelines analytics

What’s Next?

  • Εξερεύνησε document comparison για ανάδειξη αλλαγών μεταξύ εκδόσεων
  • Βυθίσου στο GroupDocs.Metadata για συγγραφέα, ημερομηνία δημιουργίας και προσαρμοσμένες ιδιότητες
  • Συνδέσου με βάσεις δεδομένων, REST APIs ή αποθηκευτικό cloud για αυτοματισμό από άκρη σε άκρη
  • Δημιούργησε προγραμματισμένες εργασίες που σαρώσουν περιοδικά αποθετήρια και ενημερώνουν ευρετήρια

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

Resources for Continued Learning: