Java에서 워드 문서 비교 – Java Word Document Comparison

<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-comparison</artifactId>
    <version>25.2</version>
</dependency>

implementation 'com.groupdocs:groupdocs-comparison:25.2'

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

repositories {
    maven { url 'https://releases.groupdocs.com/comparison/java/' }
}
dependencies {
    implementation 'com.groupdocs:groupdocs-comparison:25.2'
}

import com.groupdocs.comparison.Comparer;

public class CompareDocuments {
    public static void main(String[] args) throws Exception {
        // Initialize the Comparer with a source document
        try (Comparer comparer = new Comparer("YOUR_DOCUMENT_DIRECTORY/source.docx")) {
            // The rest of our code will go here
        }
    }
}

// Add a target document for comparison
comparer.add("YOUR_DOCUMENT_DIRECTORY/target1.docx");

comparer.add("YOUR_DOCUMENT_DIRECTORY/target1.docx");
comparer.add("YOUR_DOCUMENT_DIRECTORY/target2.docx");
// Add as many as needed

// Compare documents and output the result
final Path resultPath = comparer.compare("YOUR_OUTPUT_DIRECTORY/compare_result.docx");

import com.groupdocs.comparison.Comparer;
import java.nio.file.Path;

public class DocumentComparisonDemo {
    public static void main(String[] args) {
        try {
            // Set up your document paths
            String sourceDoc = "path/to/your/source.docx";
            String targetDoc = "path/to/your/target.docx";
            String outputDoc = "path/to/your/output/comparison_result.docx";
            
            // Perform the comparison
            try (Comparer comparer = new Comparer(sourceDoc)) {
                comparer.add(targetDoc);
                Path resultPath = comparer.compare(outputDoc);
                
                System.out.println("Comparison completed successfully!");
                System.out.println("Result saved to: " + resultPath.toString());
            }
            
        } catch (Exception e) {
            System.err.println("Error during comparison: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

// Configure JVM options for better performance
// -Xmx4g -XX:+UseG1GC -XX:MaxGCPauseMillis=200

try (Comparer comparer = new Comparer(sourceDocument)) {
    comparer.add(targetDocument);
    
    // Process comparison with explicit memory management
    System.gc(); // Suggest garbage collection before intensive operation
    Path result = comparer.compare(outputDocument);
    
    // Clear references to help garbage collection
    comparer = null;
    System.gc();
}

for (DocumentPair pair : documentPairs) {
    try (Comparer comparer = new Comparer(pair.getSource())) {
        comparer.add(pair.getTarget());
        comparer.compare(pair.getOutputPath());
    }
}

documentPairs.parallelStream().forEach(pair -> {
    try (Comparer comparer = new Comparer(pair.getSource())) {
        comparer.add(pair.getTarget());
        comparer.compare(pair.getOutputPath());
    } catch (Exception e) {
        // Handle exceptions appropriately
        logger.error("Comparison failed for: " + pair.getSource(), e);
    }
});

long startTime = System.currentTimeMillis();
long startMemory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

try (Comparer comparer = new Comparer(sourceDoc)) {
    comparer.add(targetDoc);
    Path result = comparer.compare(outputDoc);
    
    long endTime = System.currentTimeMillis();
    long endMemory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
    
    System.out.println("Comparison completed in: " + (endTime - startTime) + "ms");
    System.out.println("Memory used: " + (endMemory - startMemory) / 1024 / 1024 + "MB");
}

<!-- Check for updates regularly -->
<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-comparison</artifactId>
    <version>25.2</version> <!-- Keep this current -->
</dependency>

import com.groupdocs.comparison.options.CompareOptions;
import com.groupdocs.comparison.options.style.DetalisationLevel;

CompareOptions compareOptions = new CompareOptions();
compareOptions.setDetalisationLevel(DetalisationLevel.High);
compareOptions.setShowDeletedContent(true);
compareOptions.setShowInsertedContent(true);

try (Comparer comparer = new Comparer("source.docx")) {
    comparer.add("target.docx");
    comparer.compare("detailed_result.docx", compareOptions);
}

public class DocumentComparisonService {
    
    public ComparisonResult compareDocuments(String source, String target, String output) {
        try {
            validateInputs(source, target);
            
            try (Comparer comparer = new Comparer(source)) {
                comparer.add(target);
                Path resultPath = comparer.compare(output);
                
                return new ComparisonResult(true, resultPath.toString(), "Success");
            }
            
        } catch (FileNotFoundException e) {
            return new ComparisonResult(false, null, "Document not found: " + e.getMessage());
        } catch (Exception e) {
            return new ComparisonResult(false, null, "Comparison failed: " + e.getMessage());
        }
    }
    
    private void validateInputs(String source, String target) throws IllegalArgumentException {
        if (!new File(source).exists()) {
            throw new IllegalArgumentException("Source document does not exist: " + source);
        }
        if (!new File(target).exists()) {
            throw new IllegalArgumentException("Target document does not exist: " + target);
        }
    }
}

try (Comparer comparer = new Comparer("source.docx")) {
    comparer.add("version1.docx");
    comparer.add("version2.docx");
    comparer.add("version3.docx");
    comparer.compare("multi_comparison_result.docx");
}

LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your_password");

try (Comparer comparer = new Comparer("protected_source.docx", loadOptions)) {
    // Add target document (also protected)
    LoadOptions targetOptions = new LoadOptions();
    targetOptions.setPassword("target_password");
    comparer.add("protected_target.docx", targetOptions);
    
    comparer.compare("comparison_result.docx");
}

@Service
public class DocumentComparisonService {
    
    @Autowired
    private DocumentRepository documentRepository;
    
    public String compareDocuments(Long sourceId, Long targetId) {
        Document source = documentRepository.findById(sourceId).orElseThrow();
        Document target = documentRepository.findById(targetId).orElseThrow();
        
        try (Comparer comparer = new Comparer(source.getFilePath())) {
            comparer.add(target.getFilePath());
            String outputPath = generateOutputPath(sourceId, targetId);
            comparer.compare(outputPath);
            return outputPath;
        } catch (Exception e) {
            throw new DocumentComparisonException("Failed to compare documents", e);
        }
    }
}

CompareOptions options = new CompareOptions();
options.setInsertedItemStyle(new StyleSettings());
options.getInsertedItemStyle().setFontColor(Color.BLUE);
options.getInsertedItemStyle().setHighlightColor(Color.LIGHT_GRAY);

options.setDeletedItemStyle(new StyleSettings());
options.getDeletedItemStyle().setFontColor(Color.RED);
options.getDeletedItemStyle().setStrikethrough(true);

comparer.compare("styled_result.docx", options);