compare pdf java – जावा में प्रोग्रामेटिक रूप से PDF फ़ाइलों की तुलना कैसे करें

यदि आप एक जावा डेवलपर हैं जिन्हें compare pdf java फ़ाइलों को तेज़ और सटीक रूप से तुलना करने की आवश्यकता है, तो आप सही जगह पर आए हैं। चाहे आप एक कंटेंट‑मैनेजमेंट सिस्टम बना रहे हों, कानूनी अनुबंधों में संस्करण‑नियंत्रण जोड़ रहे हों, या उत्पन्न रिपोर्टों के लिए QA को स्वचालित कर रहे हों, मैन्युअल साइड‑बाय‑साइड जाँचें त्रुटिप्रवण और समय‑साध्य होती हैं। GroupDocs.Comparison for Java आपको एकल, विश्वसनीय API प्रदान करता है जो इन्सर्शन, डिलीशन, फ़ॉर्मेटिंग परिवर्तन और यहाँ तक कि स्थानांतरित पैराग्राफ़ को भी पहचानता है—बिना आपको स्वयं जटिल डिफ़ लॉजिक लिखे।

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

त्वरित उत्तर

  • कौन सी लाइब्रेरी मुझे जावा में PDF फ़ाइलों की तुलना करने देती है? GroupDocs.Comparison for Java.
  • क्या मुझे लाइसेंस की आवश्यकता है? सीखने के लिए एक फ्री ट्रायल काम करता है; उत्पादन के लिए पूर्ण लाइसेंस आवश्यक है।
  • कौन सा जावा संस्करण आवश्यक है? न्यूनतम Java 8, Java 11+ की सिफ़ारिश की जाती है।
  • क्या मैं दस्तावेज़ों को डिस्क पर सहेजे बिना तुलना कर सकता हूँ? हाँ – InputStream‑आधारित ओवरलोड्स का उपयोग करके सब कुछ मेमोरी में रखें।
  • मैं परिवर्तन निर्देशांक कैसे प्राप्त करूँ? compare को कॉल करने से पहले CompareOptions पर setCalculateCoordinates(true) कॉल करें।

जावा में PDF फ़ाइलों की तुलना कैसे करें (compare pdf java)?

दो PDFs को Comparer इंस्टेंस के साथ लोड करें, आवश्यकतानुसार CompareOptions कॉन्फ़िगर करें, और compare को कॉल करें। यह मेथड एक ChangeInfo[] एरे लौटाता है जो बताता है कि क्या बदला, कहाँ, और कैसे। यह पूरा वर्कफ़्लो दस लाइनों से कम जावा कोड में लिखा जा सकता है, और लाइब्रेरी सभी फ़ॉर्मेट‑विशिष्ट जटिलताओं का ख़्याल रखती है।

“compare pdf files java” क्या है?

वाक्यांश compare pdf files java जावा एप्लिकेशन में दो PDF (या समर्थित) दस्तावेज़ों का प्रोग्रामेटिक विश्लेषण करके विस्तृत डिफ़ उत्पन्न करने की प्रक्रिया को दर्शाता है। डिफ़ में इन्सर्टेड, डिलीटेड, और संशोधित टेक्स्ट, इमेज, टेबल, और यहाँ तक कि स्थानांतरित सेक्शन शामिल होते हैं, जो एक संरचित सूची के रूप में पैकेज किए जाते हैं जिसे रेंडर, लॉग या डाउनस्ट्रीम सर्विसेज को भेजा जा सकता है।

GroupDocs.Comparison for Java का उपयोग क्यों करें?

GroupDocs.Comparison 60 से अधिक इनपुट और आउटपुट फ़ॉर्मेट्स का समर्थन करता है, जिसमें PDF, DOCX, XLSX, PPTX, HTML, और इमेज शामिल हैं, जबकि लेआउट को बरकरार रखता है। यह मल्टी‑हंड्रेड‑पेज फ़ाइलों को पूरी दस्तावेज़ को मेमोरी में लोड किए बिना प्रोसेस कर सकता है, और सामान्य 50‑पेज PDFs के लिए एक सेकंड से कम समय में परिणाम देता है। बिल्ट‑इन विकल्प आपको स्टाइल परिवर्तन को अनदेखा करने, स्थानांतरित कंटेंट का पता लगाने, और प्रत्येक परिवर्तन के पेज निर्देशांक की गणना करने की सुविधा देते हैं।

जावा में प्रोग्रामेटिक रूप से PDF फ़ाइलों की तुलना कैसे करें

नीचे वह एंड‑टू‑एंड फ्लो है जिसे आप अपने प्रोजेक्ट में फॉलो करेंगे। प्रत्येक चरण को संबंधित प्लेसहोल्डर से पहले समझाया गया है, ताकि आप हमेशा जान सकें कि कोड क्यों मौजूद है।

आवश्यकताएँ और आपको क्या चाहिए

  • Java Development Kit (JDK) – संस्करण 8 या उससे ऊपर (Java 11+ बेहतर गार्बेज‑कलेक्शन और मॉड्यूल सपोर्ट देता है)।
  • IDE – IntelliJ IDEA, Eclipse, या कोई भी एडिटर जो Maven को समझता हो।
  • Maven – डिपेंडेंसी मैनेजमेंट के लिए; ट्यूटोरियल Maven के स्टैंडर्ड pom.xml का उपयोग करता है।
  • Sample documents – दो PDFs (या कोई भी समर्थित फ़ॉर्मेट) जिनमें हल्के अंतर हों, परीक्षण के लिए।

GroupDocs.Comparison for Java सेट‑अप करना

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>

Pro Tip: हमेशा सुनिश्चित करें कि आपके पास GroupDocs डाउनलोड पेज पर नवीनतम स्थिर संस्करण है। नए रिलीज़ अक्सर अतिरिक्त फ़ॉर्मेट सपोर्ट और प्रदर्शन सुधार जोड़ते हैं।

सामान्य सेटअप समस्याएँ और समाधान

  • “Repository not found” – सुनिश्चित करें कि <repositories> एलिमेंट <dependencies> से पहले आता है।
  • “ClassNotFoundException” – Maven रीफ़्रेश चलाएँ (जैसे, IntelliJ में Maven → Reload project) ताकि JARs आपके क्लासपाथ में पुल हो जाएँ।

लाइसेंस विकल्पों की व्याख्या

  1. Free Trial – सीखने और छोटे‑स्केल डेमो के लिए आदर्श।
  2. Temporary License – विस्तारित मूल्यांकन के लिए 30‑दिन की कुंजी का अनुरोध करें।
  3. Full License – उत्पादन के लिए आवश्यक, अनलिमिटेड फ़ाइल साइज, और प्रायोरिटी सपोर्ट।

बेसिक प्रोजेक्ट स्ट्रक्चर

your-project/
├── src/main/java/
│   └── com/yourcompany/comparison/
│       └── DocumentComparison.java
├── src/test/resources/
│   ├── source.docx
│   └── target.docx
└── pom.xml

कोर इम्प्लीमेंटेशन: स्टेप‑बाय‑स्टेप गाइड

Comparer क्लास को समझना

Comparer क्लास GroupDocs.Comparison में सभी तुलना ऑपरेशन्स का केंद्रीय एंट्री पॉइंट है।

import com.groupdocs.comparison.Comparer;

try (Comparer comparer = new Comparer("sourceFilePath")) {
    comparer.add("targetFilePath");
    // Your comparison logic goes here
}

Why use try‑with‑resources? क्योंकि Comparer AutoCloseable को इम्प्लीमेंट करता है, यह पैटर्न सुनिश्चित करता है कि नेटिव रिसोर्सेज (मेमोरी बफ़र, टेम्प फ़ाइलें) स्वचालित रूप से रिलीज़ हो जाएँ, जिससे बड़े PDFs प्रोसेस करते समय मेमोरी लीक नहीं होती।

Feature 1: Getting Change Coordinates

यह फ़ीचर प्रत्येक पहचाने गए परिवर्तन के सटीक पेज‑लेवल X/Y निर्देशांक लौटाता है, जिससे आप विज़ुअल डिफ़ व्यूअर्स बना सकते हैं।

उपयोग कब करें
  • वेब‑आधारित डॉक्यूमेंट रिव्यूअर बनाना जो एडिट्स को हाइलाइट करता है।
  • ऑडिट लॉग जनरेट करना जो प्रत्येक मॉडिफ़िकेशन का स्थान दर्शाता है।
  • ऐसे PDF व्यूअर्स के साथ इंटीग्रेट करना जो एनोटेशन ओवरले सपोर्ट करते हैं।
इम्प्लीमेंटेशन विवरण
import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.result.ChangeInfo;

String sourceFilePath = "path/to/source.docx";
String targetFilePath = "path/to/target.docx";

try (Comparer comparer = new Comparer(sourceFilePath)) {
    // Add the target document for comparison.
    comparer.add(targetFilePath);

CompareOptions तुलना व्यवहार को कॉन्फ़िगर करता है, जैसे कि निर्देशांक गणना को सक्षम करना।

निर्देशांक गणना सक्षम करें:

import com.groupdocs.comparison.options.CompareOptions;

final Path resultPath = comparer.compare(
        new CompareOptions.Builder()
                .setCalculateCoordinates(true)
                .build());

परिवर्तन जानकारी निकालें और उसके साथ काम करें:

ChangeInfo[] changes = comparer.getChanges();
for (ChangeInfo change : changes) {
    System.out.printf("Change Type: %s, X: %f, Y: %f, Text: %s%n",
            change.getType(), change.getBox().getX(), change.getBox().getY(), change.getText());
}

Performance Note: निर्देशांक सक्षम करने से लगभग 15‑20 % ओवरहेड बढ़ता है; जब लोकेशन डेटा की आवश्यकता न हो तो इसे बंद रखें।

Feature 2: Getting Changes from File Paths

यदि आपको केवल यह सूची चाहिए कि क्या बदला, तो यह मेथड बिना निर्देशांक के हल्का ChangeInfo[] लौटाता है।

ChangeInfo एकल पहचाने गए परिवर्तन को दर्शाता है, जिसमें उसका प्रकार और स्थान शामिल है।

परफेक्ट फ़र
  • प्लेन‑टेक्स्ट परिवर्तन सारांश जनरेट करना।
  • रात‑भर चलने वाले बैच जॉब्स जो हजारों डॉक्यूमेंट पेयर्स की तुलना करते हैं।
  • जल्दी से जांचना कि दो संस्करण समान हैं या नहीं।
इम्प्लीमेंटेशन
try (Comparer comparer = new Comparer(sourceFilePath)) {
    comparer.add(targetFilePath);

अतिरिक्त विकल्पों के बिना तुलना चलाएँ:

final Path resultPath = comparer.compare();
ChangeInfo[] changes = comparer.getChanges();
System.out.println("\nCount of changes: " + changes.length);
}

Best Practice: हमेशा changes.length जांचें। खाली एरे का मतलब है दोनों दस्तावेज़ समान हैं, जिससे आप डाउनस्ट्रीम प्रोसेसिंग को स्किप कर सकते हैं।

Feature 3: Working with Streams

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

सामान्य उपयोग केस
  • Spring Boot कंट्रोलर में फ़ाइल अपलोड स्वीकार करना और ऑन‑द‑फ़्लाई तुलना करना।
  • AWS S3, Azure Blob, या Google Cloud Storage से सीधे ByteArrayInputStream में PDFs खींचना।
  • डेटाबेस BLOB कॉलम में संग्रहीत दस्तावेज़ों की तुलना करना।
स्ट्रीम इम्प्लीमेंटेशन
import java.io.FileInputStream;
import java.io.InputStream;

try (InputStream sourceStream = new FileInputStream(sourceFilePath);
     InputStream targetStream = new FileInputStream(targetFilePath);
     Comparer comparer = new Comparer(sourceStream)) {
    comparer.add(targetStream);

उसी तुलना कॉल के साथ आगे बढ़ें:

final Path resultPath = comparer.compare();
ChangeInfo[] changes = comparer.getChanges();
System.out.println("\nCount of changes: " + Arrays.toString(changes).length);
}

Memory Tip: try‑with‑resources ब्लॉक सुनिश्चित करता है कि स्ट्रीम्स स्वचालित रूप से बंद हो जाएँ, जो कई बड़े PDFs को मल्टी‑थ्रेडेड सर्विस में हैंडल करते समय महत्वपूर्ण है।

Feature 4: Extracting Target Text

कभी‑कभी आपको वह सटीक टेक्स्ट स्निपेट चाहिए जो जोड़ा या हटाया गया हो, ईमेल अलर्ट या चेंज‑लॉग एंट्रीज़ के लिए।

व्यावहारिक अनुप्रयोग
  • एक नोटिफ़िकेशन ईमेल भेजना जिसमें इन्सर्टेड पैराग्राफ़ शामिल हो।
  • UI ग्रिड को पॉप्युलेट करना जो “पुराना बनाम नया” टेक्स्ट साइड‑बाय‑साइड दिखाता है।
  • नियामक दस्तावेज़ों का ऑडिट करना ताकि विशिष्ट वाक्यांश परिवर्तनों को ट्रैक किया जा सके।
इम्प्लीमेंटेशन
try (Comparer comparer = new Comparer(sourceFilePath)) {
    comparer.add(targetFilePath);
    
    final Path resultPath = comparer.compare();
    ChangeInfo[] changes = comparer.getChanges();

    for (ChangeInfo change : changes) {
        String text = change.getText();
        System.out.println(text);
    }
}

Filtering Tip: ChangeInfo.getChangeType() का उपयोग करके केवल इन्सर्ट (INSERT) या डिलीशन (DELETE) पर फोकस करें।

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

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

Problem: “File not found” जबकि फ़ाइल मौजूद है।
Solution: विकास के दौरान एब्सोल्यूट पाथ्स का उपयोग करें या IDE के वर्किंग डायरेक्टरी को सत्यापित करें। Windows पर बैकस्लैश (\\) को एस्केप करें या फ़ॉरवर्ड स्लैश (/) का उपयोग करें।

// Good
String path = "C:/Users/yourname/documents/test.docx";
// Or
String path = "C:\\Users\\yourname\\documents\\test.docx";

2. बड़े फ़ाइलों के साथ मेमोरी लीक्स

Problem: 200‑पेज PDFs की तुलना करते समय OutOfMemoryError।
Solution: हमेशा Comparer को try‑with‑resources ब्लॉक में रैप करें और स्ट्रीम‑आधारित ओवरलोड्स को प्राथमिकता दें, जो केवल आवश्यक पेजेज को मेमोरी में रखता है।

3. असमर्थित फ़ाइल फ़ॉर्मेट्स

Problem: कुछ लेगेसी फ़ॉर्मेट्स के लिए एक्सेप्शन।
Solution: आधिकारिक supported‑formats सूची (GroupDocs 60+ फ़ॉर्मेट्स सपोर्ट करता है) देखें। यदि कोई फ़ॉर्मेट सूची में नहीं है, तो तुलना से पहले उसे PDF या DOCX में बदलें।

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

Problem: तुलना अपेक्षा से अधिक समय ले रही है।
Solution:

  • जब तक आपको निर्देशांक की आवश्यकता न हो, इसे डिसेबल रखें।
  • CompareOptions.setDetectMovedBlocks(true) का उपयोग केवल तभी करें जब आपको मूव्ड‑ब्लॉक डिटेक्शन चाहिए।
  • स्वतंत्र तुलना जॉब्स को थ्रेड पूल के साथ पैरललाइज़ करें।

प्रदर्शन अनुकूलन टिप्स

सही विकल्प चुनें

CompareOptions options = new CompareOptions.Builder()
    .setCalculateCoordinates(false) // Only enable when needed
    .setDetectStyleChanges(false)   // Skip formatting if you only care about content
    .build();

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

  • सभी दस्तावेज़ों को एक साथ लोड करने के बजाय बैच में प्रोसेस करें।
  • 50 MB से बड़ी फ़ाइलों के लिए स्ट्रीमिंग API का उपयोग करें।
  • क्लीन‑अप की गारंटी के लिए try‑with‑resources पर भरोसा रखें।

कैशिंग रणनीतियाँ

// Pseudo-code for caching concept
String cacheKey = generateCacheKey(sourceFile, targetFile);
if (cache.contains(cacheKey)) {
    return cache.get(cacheKey);
}

वास्तविक‑दुनिया के परिदृश्य और समाधान

Scenario 1: Content Management System

public class ArticleVersionComparison {
    public List<ChangeInfo> compareVersions(String oldVersion, String newVersion) {
        try (Comparer comparer = new Comparer(oldVersion)) {
            comparer.add(newVersion);
            final Path result = comparer.compare();
            return Arrays.asList(comparer.getChanges());
        } catch (Exception e) {
            log.error("Failed to compare article versions", e);
            return Collections.emptyList();
        }
    }
}

Scenario 2: Automated Quality Assurance

public boolean validateReportAgainstTemplate(InputStream report, InputStream template) {
    try (Comparer comparer = new Comparer(template)) {
        comparer.add(report);
        comparer.compare();
        ChangeInfo[] changes = comparer.getChanges();
        
        // Only allow certain types of changes
        return Arrays.stream(changes)
                .allMatch(change -> isAllowedChange(change));
    } catch (Exception e) {
        return false;
    }
}

Scenario 3: Batch Document Processing

public void processBatchComparison(List<DocumentPair> documents) {
    documents.parallelStream().forEach(pair -> {
        try (Comparer comparer = new Comparer(pair.getSource())) {
            comparer.add(pair.getTarget());
            Path result = comparer.compare();
            // Process results...
        } catch (Exception e) {
            log.error("Failed to process document pair: " + pair, e);
        }
    });
}

उन्नत फीचर्स और बेस्ट प्रैक्टिसेज

विभिन्न फ़ाइल फ़ॉर्मेट्स के साथ काम करना

public boolean isFormatSupported(String filePath) {
    String extension = getFileExtension(filePath);
    List<String> supportedFormats = Arrays.asList(
        ".docx", ".pdf", ".txt", ".rtf", ".odt", // Add more as needed
    );
    return supportedFormats.contains(extension.toLowerCase());
}

बड़े दस्तावेज़ों को संभालना

CompareOptions largeDocOptions = new CompareOptions.Builder()
    .setCalculateCoordinates(false)  // Saves memory
    .setDetectStyleChanges(false)    // Focuses on content only
    .setWordsLimit(1000)             // Limits processing scope
    .build();

एरर हैंडलिंग पैटर्न

public ComparisonResult compareDocuments(String source, String target) {
    try (Comparer comparer = new Comparer(source)) {
        comparer.add(target);
        Path result = comparer.compare();
        
        return ComparisonResult.success(comparer.getChanges());
        
    } catch (SecurityException e) {
        log.error("Access denied when comparing documents", e);
        return ComparisonResult.failure("Access denied");
    } catch (IOException e) {
        log.error("IO error during document comparison", e);
        return ComparisonResult.failure("File access error");
    } catch (Exception e) {
        log.error("Unexpected error during comparison", e);
        return ComparisonResult.failure("Comparison failed");
    }
}

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

Q: GroupDocs.Comparison के लिए न्यूनतम जावा संस्करण क्या है?
A: Java 8 न्यूनतम समर्थित संस्करण है; बेहतर गार्बेज कलेक्शन और मॉड्यूल सपोर्ट के लिए Java 11+ की सिफ़ारिश की जाती है।

Q: क्या मैं एक साथ दो से अधिक दस्तावेज़ों की तुलना कर सकता हूँ?
A: GroupDocs.Comparison एक समय में केवल एक जोड़ी की तुलना करता है। मल्टी‑डॉक्यूमेंट संस्करणिंग के लिए, दस्तावेज़ सूची पर इटरेट करें और प्रत्येक क्रमिक जोड़ी की तुलना करें, फिर परिणामस्वरूप ChangeInfo[] को बाद में एग्रीगेशन के लिए स्टोर करें।

try (Comparer comparer = new Comparer(sourceDocument)) {
    comparer.add(targetDocument1);
    comparer.add(targetDocument2);
    comparer.add(targetDocument3);
    // Now compare against all targets
}

Q: बहुत बड़े दस्तावेज़ों (100 MB+) को कैसे संभालें?
A:

  • जब तक आपको सटीक स्थानों की आवश्यकता न हो, निर्देशांक गणना डिसेबल रखें।
  • पूरी फ़ाइल को RAM में लोड करने से बचने के लिए स्ट्रीम‑आधारित API को प्राथमिकता दें।
  • यदि आपको केवल विशिष्ट सेक्शन में परिवर्तन चाहिए, तो प्रोसेसिंग को पेज‑रेंज में विभाजित करें।
  • JVM हीप उपयोग की निगरानी करें और -Xmx को तदनुसार ट्यून करें।

Q: क्या आउटपुट में परिवर्तनों को विज़ुअली हाइलाइट करने का कोई तरीका है?
A: हाँ। ChangeInfo[] प्राप्त करने के बाद, आप GroupDocs.Watermark या किसी भी PDF लाइब्रेरी का उपयोग करके नया PDF जनरेट कर सकते हैं, जहाँ लौटाए गए निर्देशांक पर आयतें ड्रॉ की जाती हैं। यह “रेड‑लाइन” संस्करण उपयोगकर्ता किसी भी PDF व्यूअर में देख सकते हैं।

CompareOptions options = new CompareOptions.Builder()
    .setShowInsertedContent(true)
    .setShowDeletedContent(true)
    .setGenerateOutputDocument(true)
    .build();

Q: पासवर्ड‑प्रोटेक्टेड दस्तावेज़ों को कैसे हैंडल करें?
A: Comparer कंस्ट्रक्टर में पासवर्ड पास करें या compare कॉल करने से पहले LoadOptions ऑब्जेक्ट पर सेट करें। लाइब्रेरी मेमोरी में दस्तावेज़ को डिक्रिप्ट करती है, इसलिए पासवर्ड कभी भी फ़ाइल सिस्टम को नहीं छूता।

LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your-password");

try (Comparer comparer = new Comparer(protectedDocument, loadOptions)) {
    // Comparison logic here
}

Q: क्या मैं परिवर्तन पहचान को कस्टमाइज़ कर सकता हूँ?
A: बिल्कुल। CompareOptions में setIgnoreFormatting(true), setDetectMovedBlocks(true), और setGranularity(Granularity.WORD) जैसे फ़्लैग्स उपलब्ध हैं। इन्हें अपने बिज़नेस नियमों के अनुसार एडजस्ट करें—उदाहरण के लिए, फ़ॉन्ट परिवर्तन को इग्नोर करें जबकि मूव्ड पैराग्राफ़ का पता लगाते रहें।

CompareOptions options = new CompareOptions.Builder()
    .setDetectStyleChanges(false)     // Ignore formatting changes
    .setSensitivityOfComparison(100)  // Adjust sensitivity (0‑100)
    .build();

Q: Spring Boot के साथ इसे इंटीग्रेट करने का सबसे अच्छा तरीका क्या है?
A: एक @Service बीन्स बनाएं जो लाइसेंस पाथ को इंजेक्ट करे, फिर एक @RestController एंडपॉइंट एक्सपोज़ करें जो MultipartFile अपलोड स्वीकार करे। कंट्रोलर के अंदर, MultipartFile को InputStream में बदलें और स्ट्रीम‑आधारित तुलना मेथड को कॉल करें। फ्रंट‑एंड रेंडरिंग के लिए ChangeInfo[] को JSON के रूप में रिटर्न करें।

@Service
public class DocumentComparisonService {
    
    public ComparisonResult compare(MultipartFile source, MultipartFile target) {
        // Implementation using the techniques from this guide
    }
}

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

अंतिम अद्यतन: 2026-06-15
परीक्षित संस्करण: GroupDocs.Comparison 25.2 for Java
लेखक: GroupDocs

for (ChangeInfo change : changes) {
    if (change.getType() == ComparisonAction.INSERT) {
        System.out.println("Added: " + change.getText());
    }
}

संबंधित ट्यूटोरियल