compare pdf java – Java에서 PDF 파일을 프로그래밍 방식으로 비교하는 방법

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

import com.groupdocs.comparison.Comparer;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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