जावा में दस्तावेज़ तुलना – GroupDocs API पूर्ण गाइड

परिचय

क्या आपने कभी दो दस्तावेज़ों को लाइन दर लाइन मैन्युअल रूप से तुलना करते हुए महत्वपूर्ण अंतर को नज़रअंदाज़ किया है? आप अकेले नहीं हैं। compare documents in java एक सामान्य चुनौती है, विशेष रूप से जब आपको मेटाडेटा को संरक्षित रखना हो, पासवर्ड‑सुरक्षित फ़ाइलों को संभालना हो, या कई फ़ाइलों की एक साथ तुलना करनी हो।

यह बात है: अधिकांश डेवलपर्स संघर्ष करते हैं क्योंकि वे या तो शून्य से कुछ बनाते हैं (जो बहुत समय लेता है) या बुनियादी डिफ़ टूल्स का उपयोग करते हैं जो फ़ॉर्मेटिंग, मेटाडेटा और सुरक्षा सेटिंग्स को नजरअंदाज़ करते हैं। यहीं पर GroupDocs.Comparison for Java काम आता है।

इस व्यापक ट्यूटोरियल में, आप अपने जावा एप्लिकेशन में मजबूत दस्तावेज़ तुलना को लागू करना सीखेंगे। हम बुनियादी सेटअप से लेकर उन्नत मेटाडेटा हैंडलिंग तक सब कुछ कवर करेंगे, साथ ही वास्तविक‑दुनिया के उदाहरण जो आप प्रोडक्शन में उपयोग कर सकते हैं। अंत तक, आप जानेंगे कैसे:

अपने जावा प्रोजेक्ट में GroupDocs.Comparison सेट अप करें (यह आपके सोच से आसान है)
compare documents in java मेटाडेटा की अखंडता को संरक्षित रखते हुए
java compare multiple files और java compare password protected परिदृश्यों को संभालें
बड़े‑पैमाने पर दस्तावेज़ प्रोसेसिंग के लिए प्रदर्शन को अनुकूलित करें

क्या आप अपने जावा ऐप्स में दस्तावेज़ तुलना को आसान बनाना चाहते हैं? चलिए शुरू करते हैं!

त्वरित उत्तर

क्या लाइब्रेरी मुझे जावा में दस्तावेज़ तुलना करने देती है? GroupDocs.Comparison for Java
क्या मैं एक साथ कई फ़ाइलों की तुलना कर सकता हूँ? हाँ – जितने आवश्यक हों टार्गेट दस्तावेज़ जोड़ें
मैं पासवर्ड‑सुरक्षित दस्तावेज़ों को कैसे संभालूँ? दस्तावेज़ पासवर्ड के साथ LoadOptions का उपयोग करें
क्या प्रोडक्शन के लिए लाइसेंस चाहिए? एक वैध GroupDocs लाइसेंस वॉटरमार्क और सीमाओं को हटाता है
कौन सा जावा संस्करण आवश्यक है? JDK 8+, JDK 11+ अनुशंसित

compare documents in java क्या है?

जावा में दस्तावेज़ तुलना का अर्थ है प्रोग्रामेटिक रूप से दो या अधिक फ़ाइलों के बीच अंतर—पाठ परिवर्तन, फ़ॉर्मेटिंग संपादन, या मेटाडेटा अपडेट—का पता लगाना, एक ऐसी लाइब्रेरी का उपयोग करके जो दस्तावेज़ संरचना को समझती है। GroupDocs.Comparison जटिलता को सारांशित करता है, आपको एक सरल API देता है जिससे आप एक डिफ़ दस्तावेज़ बना सकते हैं जो हर परिवर्तन को हाइलाइट करता है।

जावा के लिए GroupDocs.Comparison क्यों उपयोग करें?

समृद्ध फ़ॉर्मेट समर्थन – DOCX, PDF, XLSX, PPTX, TXT, और अधिक
मेटाडेटा हैंडलिंग – परिणाम के लिए स्रोत, लक्ष्य, या कोई मेटाडेटा न चुनें
पासवर्ड समर्थन – मैन्युअल डिक्रिप्शन के बिना संरक्षित फ़ाइलें खोलें
स्केलेबल प्रदर्शन – बैच प्रोसेसिंग, असिंक्रोनस निष्पादन, और मेमोरी‑कुशल डिज़ाइन

पूर्वापेक्षाएँ

जावा पर्यावरण: JDK 8+ (JDK 11+ अनुशंसित), पसंदीदा IDE, Maven (या Gradle)
GroupDocs.Comparison लाइब्रेरी: संस्करण 25.2 या बाद का (हमेशा नवीनतम प्राप्त करें)
लाइसेंस: फ्री ट्रायल, अस्थायी 30‑दिन लाइसेंस, या व्यावसायिक लाइसेंस

अपने प्रोजेक्ट में GroupDocs.Comparison सेट अप करना

Maven कॉन्फ़िगरेशन

सबसे पहले – अपने pom.xml में GroupDocs रिपॉजिटरी और डिपेंडेंसी जोड़ें। यहाँ अधिकांश ट्यूटोरियल अनावश्यक रूप से जटिल हो जाते हैं, लेकिन यह वास्तव में बहुत सरल है:

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

प्रो टिप: हमेशा नवीनतम संस्करण संख्या को GroupDocs रिलीज़ पेज पर देखें। नए संस्करण अक्सर प्रदर्शन सुधार और बग फ़िक्स शामिल करते हैं जो आपके सिरदर्द को बचा सकते हैं।

अपना लाइसेंस व्यवस्थित करना

यहाँ वह बात है जो अधिकांश डेवलपर्स नहीं समझते: आप उनके फ्री ट्रायल के साथ तुरंत GroupDocs.Comparison का परीक्षण शुरू कर सकते हैं। कोई क्रेडिट कार्ड आवश्यक नहीं, कोई शर्त नहीं।

आपके विकल्प:

Free Trial – परीक्षण और छोटे प्रोजेक्ट्स के लिए उत्तम। बस डाउनलोड करें और कोडिंग शुरू करें!
Temporary License – मूल्यांकन के लिए अधिक समय चाहिए? 30‑दिन का अस्थायी लाइसेंस यहाँ प्राप्त करें
Commercial License – प्रोडक्शन के लिए तैयार? मूल्य निर्धारण देखें यहाँ

फ्री ट्रायल में सभी फीचर शामिल होते हैं लेकिन आउटपुट फ़ाइलों में वॉटरमार्क जोड़ता है। विकास और परीक्षण के लिए यह आमतौर पर ठीक है।

दस्तावेज़ तुलना कार्यान्वयन: पूर्ण walkthrough

अब मुख्य भाग! हम चरण‑दर‑चरण एक पूर्ण दस्तावेज़ तुलना समाधान बनाएँगे। चिंता न करें – हम केवल “कैसे” नहीं, बल्कि प्रत्येक निर्णय के “क्यों” को भी समझाएंगे।

मेटाडेटा स्रोतों को समझना (यह महत्वपूर्ण है!)

कोडिंग शुरू करने से पहले, चलिए एक ऐसी बात पर चर्चा करते हैं जो कई डेवलपर्स को उलझन में डालती है: मेटाडेटा स्रोत। जब आप compare documents in java करते हैं, तो आपको तय करना होगा कि परिणाम में किस दस्तावेज़ का मेटाडेटा (लेखक, निर्माण तिथि, कस्टम प्रॉपर्टीज़, आदि) संरक्षित किया जाए।

GroupDocs.Comparison आपको तीन विकल्प देता है:

SOURCE – मूल दस्तावेज़ से मेटाडेटा उपयोग करें
TARGET – उस दस्तावेज़ से मेटाडेटा उपयोग करें जिससे आप तुलना कर रहे हैं
NONE – परिणाम से सभी मेटाडेटा हटाएँ

अधिकांश व्यावसायिक अनुप्रयोगों के लिए, आप स्थिरता बनाए रखने के लिए SOURCE का उपयोग करेंगे।

चरण‑दर‑चरण कार्यान्वयन

हम एक पुन: उपयोग योग्य यूटिलिटी बनाएँगे जिसे आप किसी भी प्रोजेक्ट में डाल सकते हैं।

चरण 1: आवश्यक क्लासेस इम्पोर्ट करें

import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.options.enums.MetadataType;
import com.groupdocs.comparison.options.save.SaveOptions;
import java.nio.file.Path;
import java.io.IOException;

चरण 2: Comparer इंस्टेंस बनाएं

यहीं से जादू शुरू होता है। Comparer क्लास सभी तुलना ऑपरेशन्स के लिए आपका मुख्य एंट्री पॉइंट है:

try (Comparer comparer = new Comparer("YOUR_DOCUMENT_DIRECTORY/source.docx")) {
    // All our comparison logic goes here
}

try‑with‑resources क्यों उपयोग करें? Comparer क्लास AutoCloseable को इम्प्लीमेंट करती है, जिसका अर्थ है कि जब आप समाप्त कर लेते हैं तो यह संसाधनों को सही ढंग से साफ़ करती है। यह मेमोरी लीक को रोकता है – विशेष रूप से जब कई दस्तावेज़ प्रोसेस कर रहे हों।

चरण 3: तुलना के लिए टार्गेट दस्तावेज़ जोड़ें

comparer.add("YOUR_DOCUMENT_DIRECTORY/target1.docx");

यहाँ एक कूल चीज़: आप वास्तव में कई टार्गेट दस्तावेज़ जोड़ सकते हैं और उन्हें एक ही ऑपरेशन में अपने स्रोत के खिलाफ तुलना कर सकते हैं। बस add() को कई बार कॉल करें:

comparer.add("YOUR_DOCUMENT_DIRECTORY/target1.docx");
comparer.add("YOUR_DOCUMENT_DIRECTORY/target2.docx");
comparer.add("YOUR_DOCUMENT_DIRECTORY/target3.docx");

चरण 4: मेटाडेटा हैंडलिंग कॉन्फ़िगर करें और तुलना निष्पादित करें

यहीं हम मेटाडेटा स्रोत सेट करते हैं और वास्तविक तुलना चलाते हैं:

final Path resultPath = comparer.compare("output/comparison_result.docx",
        new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)
                .build());

यहाँ क्या हो रहा है? हम GroupDocs को बता रहे हैं:

सभी जोड़े गए दस्तावेज़ों की स्रोत के खिलाफ तुलना करें
परिणाम को हमारे निर्दिष्ट पथ पर सहेजें
अंतिम परिणाम में SOURCE दस्तावेज़ का मेटाडेटा उपयोग करें

पूर्ण कार्यशील उदाहरण

आइए इसे एक मेथड में जोड़ें जिसे आप वास्तव में उपयोग कर सकते हैं:

public class DocumentComparison {
    
    public static Path compareDocumentsWithMetadata(
            String sourcePath, 
            String targetPath, 
            String outputPath) throws IOException {
        
        try (Comparer comparer = new Comparer(sourcePath)) {
            // Add the target document
            comparer.add(targetPath);
            
            // Configure comparison options
            SaveOptions saveOptions = new SaveOptions.Builder()
                    .setCloneMetadataType(MetadataType.SOURCE)
                    .build();
            
            // Execute comparison and return result path
            return comparer.compare(outputPath, saveOptions);
        }
    }
}

सामान्य समस्याएँ और उन्हें कैसे टालें

सैकड़ों डेवलपर्स को दस्तावेज़ तुलना लागू करने में मदद करने के बाद, मैंने वही समस्याएँ बार‑बार देखी हैं। यहाँ प्रमुख समस्याएँ (और उन्हें कैसे ठीक करें) हैं:

फ़ाइल पाथ समस्याएँ

समस्या: फ़ाइल मौजूद होने के बावजूद FileNotFoundException
समाधान: हमेशा पूर्ण पाथ उपयोग करें या सापेक्ष पाथ को सही ढंग से हल करें

// Instead of this:
String sourcePath = "documents/source.docx";

// Do this:
String sourcePath = Paths.get("documents", "source.docx").toAbsolutePath().toString();

मेमोरी मैनेजमेंट समस्याएँ

समस्या: बड़े दस्तावेज़ों की तुलना करते समय मेमोरी समाप्त हो जाना
समाधान: JVM हीप साइज बढ़ाएँ और उचित संसाधन प्रबंधन उपयोग करें

# Add these JVM arguments when running your application
-Xmx4g -XX:+UseG1GC

गलत मेटाडेटा हैंडलिंग

समस्या: तुलना के दौरान महत्वपूर्ण दस्तावेज़ मेटाडेटा खोना
समाधान: हमेशा स्पष्ट रूप से मेटाडेटा टाइप सेट करें – डिफ़ॉल्ट पर निर्भर न रहें

// Always be explicit about metadata handling
SaveOptions saveOptions = new SaveOptions.Builder()
        .setCloneMetadataType(MetadataType.SOURCE)  // Be explicit!
        .build();

लाइसेंस कॉन्फ़िगरेशन समस्याएँ

समस्या: प्रोडक्शन में वॉटरमार्क दिखाई देना
समाधान: Comparer इंस्टेंस बनाने से पहले सुनिश्चित करें कि आपका लाइसेंस सही ढंग से लोड हुआ है

// Load license at application startup
License license = new License();
license.setLicense("path/to/your/license.lic");

प्रोडक्शन उपयोग के लिए सर्वोत्तम प्रथाएँ

वास्तविक‑दुनिया के अनुभव के आधार पर, यहाँ वे प्रथाएँ हैं जो शौकिया कार्यान्वयन को प्रोडक्शन‑तैयार समाधान से अलग करती हैं:

त्रुटि हैंडलिंग जो वास्तव में मदद करती है

सिर्फ एक्सेप्शन को पकड़ें नहीं – उन्हें सार्थक रूप से हैंडल करें:

public ComparisonResult compareDocuments(String source, String target) {
    try (Comparer comparer = new Comparer(source)) {
        comparer.add(target);
        Path result = comparer.compare("output.docx", 
            new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)
                .build());
        
        return new ComparisonResult(true, result.toString(), null);
        
    } catch (IOException e) {
        logger.error("File access error during comparison", e);
        return new ComparisonResult(false, null, "Unable to access document files");
        
    } catch (Exception e) {
        logger.error("Unexpected error during document comparison", e);
        return new ComparisonResult(false, null, "Document comparison failed");
    }
}

प्रदर्शन अनुकूलन

उच्च‑वॉल्यूम परिदृश्यों के लिए, इन अनुकूलनों पर विचार करें:

जब संभव हो तो Comparer इंस्टेंस को पुन: उपयोग करें (परंतु थ्रेड सुरक्षा का ध्यान रखें)
सिस्टम संसाधनों को अधिक लोड से बचाने के लिए दस्तावेज़ों को बैच में प्रोसेस करें
बड़े दस्तावेज़ों के लिए असिंक्रोनस प्रोसेसिंग उपयोग करें
मेमोरी उपयोग की निगरानी करें और JVM सेटिंग्स को तदनुसार समायोजित करें

सुरक्षा विचार

संवेदनशील दस्तावेज़ों को संभालते समय:

फ़ाइल प्रकारों को वैध करें प्रोसेसिंग से पहले
उचित एक्सेस कंट्रोल लागू करें
उपयोग के बाद तुरंत टेम्पररी फ़ाइलें साफ़ करें
तुलना परिणामों को एन्क्रिप्ट करने पर विचार करें

वास्तविक‑दुनिया के अनुप्रयोग और उपयोग केस

आइए देखें कि डेवलपर्स प्रोडक्शन में GroupDocs.Comparison का वास्तविक उपयोग कैसे कर रहे हैं:

कानूनी दस्तावेज़ समीक्षा

कानूनी फर्में अनुबंधों और कानूनी समझौतों में बदलावों को ट्रैक करने के लिए दस्तावेज़ तुलना का उपयोग करती हैं। यहाँ मेटाडेटा संरक्षण फीचर महत्वपूर्ण है क्योंकि उन्हें दस्तावेज़ की उत्पत्ति बनाए रखनी होती है।

// Typical legal document comparison workflow
public void reviewContractChanges(String originalContract, String revisedContract) {
    try (Comparer comparer = new Comparer(originalContract)) {
        comparer.add(revisedContract);
        
        SaveOptions options = new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)  // Preserve original metadata
                .build();
        
        Path result = comparer.compare("contract_review.docx", options);
        
        // Send result to legal team for review
        notifyLegalTeam(result);
    }
}

कंटेंट मैनेजमेंट सिस्टम

CMS प्लेटफ़ॉर्म संस्करण नियंत्रण और परिवर्तन ट्रैकिंग के लिए दस्तावेज़ तुलना का उपयोग करते हैं:

public class CMSDocumentVersioning {
    
    public VersionComparisonResult compareVersions(
            DocumentVersion current, 
            DocumentVersion previous) {
        
        try (Comparer comparer = new Comparer(current.getFilePath())) {
            comparer.add(previous.getFilePath());
            
            String outputName = String.format("comparison_%s_vs_%s.docx", 
                current.getVersionNumber(), 
                previous.getVersionNumber());
            
            Path result = comparer.compare(outputName, 
                new SaveOptions.Builder()
                    .setCloneMetadataType(MetadataType.SOURCE)
                    .build());
            
            return new VersionComparisonResult(result, current, previous);
        }
    }
}

वित्तीय दस्तावेज़ विश्लेषण

वित्तीय संस्थान नियामक अनुपालन और ऑडिट ट्रेल्स के लिए इसका उपयोग करते हैं:

public AuditResult auditFinancialDocument(String originalReport, String submittedReport) {
    // Compare submitted report against original
    // Metadata preservation is critical for audit compliance
    try (Comparer comparer = new Comparer(originalReport)) {
        comparer.add(submittedReport);
        
        Path auditResult = comparer.compare("audit_comparison.docx",
            new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)
                .build());
        
        return generateAuditReport(auditResult);
    }
}

प्रदर्शन अनुकूलन और स्केलिंग

जब आप गंभीर दस्तावेज़ वॉल्यूम को संभालने के लिए तैयार हों, ये रणनीतियाँ आपके एप्लिकेशन को प्रतिक्रियाशील रखेंगी:

मेमोरी मैनेजमेंट

बड़े दस्तावेज़ जल्दी से उपलब्ध मेमोरी खा सकते हैं। इन्हें कुशलता से संभालने का तरीका यहाँ है:

public class OptimizedDocumentProcessor {
    
    private final ExecutorService executor = Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors());
    
    public CompletableFuture<Path> compareDocumentsAsync(
            String source, 
            String target, 
            String output) {
        
        return CompletableFuture.supplyAsync(() -> {
            try (Comparer comparer = new Comparer(source)) {
                comparer.add(target);
                return comparer.compare(output, 
                    new SaveOptions.Builder()
                        .setCloneMetadataType(MetadataType.SOURCE)
                        .build());
            }
        }, executor);
    }
}

बैच प्रोसेसिंग

कई दस्तावेज़ तुलना के लिए, बैच प्रोसेसिंग आपका मित्र है:

public List<ComparisonResult> processBatch(List<DocumentPair> documentPairs) {
    return documentPairs.parallelStream()
        .map(this::compareDocumentPair)
        .collect(Collectors.toList());
}

private ComparisonResult compareDocumentPair(DocumentPair pair) {
    try (Comparer comparer = new Comparer(pair.getSourcePath())) {
        comparer.add(pair.getTargetPath());
        Path result = comparer.compare(pair.getOutputPath(),
            new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)
                .build());
        return new ComparisonResult(pair, result, true);
    } catch (Exception e) {
        return new ComparisonResult(pair, null, false, e.getMessage());
    }
}

समस्या निवारण गाइड

जब चीज़ें गलत होती हैं (और कभी‑कभी होती हैं), यहाँ आपका डिबगिंग चेकलिस्ट है:

“Comparison Failed” त्रुटियाँ

सबसे सामान्य कारण:

असमर्थित फ़ाइल फ़ॉर्मेट
भ्रष्ट स्रोत दस्तावेज़
अपर्याप्त मेमोरी
फ़ाइल अनुमति समस्याएँ

डिबगिंग चरण:

// Add comprehensive logging to identify the issue
logger.debug("Starting comparison: source={}, target={}", sourcePath, targetPath);

try (Comparer comparer = new Comparer(sourcePath)) {
    logger.debug("Comparer initialized successfully");
    
    comparer.add(targetPath);
    logger.debug("Target document added successfully");
    
    Path result = comparer.compare(outputPath, saveOptions);
    logger.info("Comparison completed successfully: result={}", result);
    
    return result;
} catch (Exception e) {
    logger.error("Comparison failed", e);
    throw new DocumentComparisonException("Failed to compare documents", e);
}

प्रदर्शन समस्याएँ

यदि तुलना बहुत समय ले रही है:

दस्तावेज़ आकार जांचें – 100 MB से बड़ी फ़ाइलों को विशेष हैंडलिंग की आवश्यकता हो सकती है
मेमोरी उपयोग की निगरानी – आवश्यकता पड़ने पर हीप साइज बढ़ाएँ
फ़ाइल I/O प्रदर्शन सत्यापित करें – धीमी स्टोरेज ऑपरेशन्स को बाधित कर सकती है
दस्तावेज़ फ़ॉर्मेट पर विचार करें – कुछ फ़ॉर्मेट प्रोसेस करने में अधिक जटिल होते हैं

मेमोरी लीक

संकेत कि आपके पास मेमोरी लीक हो सकता है:

समय के साथ एप्लिकेशन प्रदर्शन घटता है
कई दस्तावेज़ प्रोसेस करने के बाद OutOfMemoryError
उच्च गार्बेज कलेक्शन गतिविधि

समाधान: हमेशा try‑with‑resources उपयोग करें और प्रोफ़ाइलिंग टूल्स से अपने एप्लिकेशन की निगरानी करें।

पासवर्ड‑सुरक्षित फ़ाइलों को संभालना

यदि आपको java compare password protected दस्तावेज़ों की तुलना करनी है, तो स्रोत या लक्ष्य खोलते समय LoadOptions का उपयोग करें:

LoadOptions loadOptions = new LoadOptions("your_password");
try (Comparer comparer = new Comparer("protected_document.docx", loadOptions)) {
    // Process password‑protected document
}

कैसे जावा में पासवर्ड‑सुरक्षित दस्तावेज़ तुलना करें

नियमित उद्योगों में पासवर्ड‑सुरक्षित फ़ाइलें आम हैं। पासवर्ड को LoadOptions के माध्यम से पास करके, आप तुलना प्रवाह को अपरिवर्तित रखते हैं जबकि लाइब्रेरी को फ़ाइल को सुरक्षित रूप से डिक्रिप्ट करने की अनुमति देते हैं। कभी भी पासवर्ड को हार्ड‑कोड न करें; उन्हें सुरक्षित वॉल्ट या एनवायरनमेंट वैरिएबल में रखें और रनटाइम पर इंजेक्ट करें।

जावा में बड़े दस्तावेज़ कैसे संभालें

जब दस्तावेज़ कई सौ मेगाबाइट से अधिक हो जाएँ, तो आप धीमी प्रोसेसिंग या अधिक मेमोरी खपत का सामना कर सकते हैं। इसे कम करने के लिए:

JVM हीप बढ़ाएँ (-Xmx), विशेष रूप से बैच जॉब्स के लिए।
स्ट्रीमिंग सक्षम करें जहाँ संभव हो – GroupDocs.Comparison आंतरिक रूप से फ़ाइलों को चंक्स में प्रोसेस करता है, लेकिन आप स्वयं पूरी फ़ाइल को मेमोरी में लोड करने से बचकर मेमोरी दबाव को और कम कर सकते हैं।
तुलनाओं को असिंक्रोनस रूप से चलाएँ (ऊपर के async उदाहरण देखें) ताकि आपका UI प्रतिक्रियाशील रहे।
यदि व्यावसायिक लॉजिक अनुमति देता है, तो बहुत बड़े PDF को तुलना से पहले तार्किक सेक्शन में विभाजित करें।

Spring Boot के साथ एकीकरण

माइक्रोसर्विसेज़ बनाने वाले डेवलपर्स के लिए, तुलना लॉजिक को एक Spring सर्विस बीन्स में रैप करें:

@Service
public class DocumentComparisonService {
    
    public ComparisonResult compareDocuments(String source, String target) {
        try (Comparer comparer = new Comparer(source)) {
            comparer.add(target);
            Path result = comparer.compare("output.docx",
                new SaveOptions.Builder()
                    .setCloneMetadataType(MetadataType.SOURCE)
                    .build());
            return new ComparisonResult(result);
        }
    }
}

अक्सर पूछे जाने वाले प्रश्न

प्रश्न: क्या मैं एक साथ दो से अधिक दस्तावेज़ तुलना कर सकता हूँ?
उत्तर: बिल्कुल! तुलना निष्पादित करने से पहले comparer.add() के साथ कई टार्गेट दस्तावेज़ जोड़ें।

प्रश्न: GroupDocs.Comparison कौन‑से फ़ाइल फ़ॉर्मेट सपोर्ट करता है?
उत्तर: यह DOCX, PDF, XLSX, PPTX, TXT, और कई अन्य फ़ॉर्मेट सपोर्ट करता है। पूरी सूची आधिकारिक दस्तावेज़ में देखें।

प्रश्न: मैं पासवर्ड‑सुरक्षित दस्तावेज़ों को कैसे संभालूँ?
उत्तर: Comparer इंस्टेंस बनाते समय पासवर्ड प्रदान करने के लिए LoadOptions क्लास का उपयोग करें (ऊपर के उदाहरण देखें)।

प्रश्न: क्या GroupDocs.Comparison थ्रेड‑सेफ़ है?
उत्तर: एकल Comparer इंस्टेंस थ्रेड‑सेफ़ नहीं है, लेकिन आप समानांतर थ्रेड्स में कई इंस्टेंस सुरक्षित रूप से उपयोग कर सकते हैं।

प्रश्न: बड़े दस्तावेज़ों के प्रदर्शन को कैसे सुधारूँ?
उत्तर: JVM हीप बढ़ाएँ (-Xmx), फ़ाइलों को असिंक्रोनस रूप से प्रोसेस करें, उन्हें बैच में रखें, और उपयुक्त होने पर Comparer ऑब्जेक्ट्स को पुन: उपयोग करें।

अतिरिक्त संसाधन

GroupDocs.Comparison Documentation – व्यापक API रेफ़रेंस और उदाहरण
GroupDocs Community Forum – अन्य डेवलपर्स से मदद प्राप्त करें

अंतिम अपडेट: 2026-02-23
परीक्षित संस्करण: GroupDocs.Comparison 25.2
लेखक: GroupDocs