GroupDocs Viewer Java Öğreticisi: Word’ü HTML’ye Dönüştürme ve Yorumlu Belgeleri Görüntüleme

Giriş

Eğer convert Word to HTML yaparken her bir incelemenin notunu, yorumunu veya ek açıklamasını korumak istiyorsanız doğru yerdesiniz. Birçok Java geliştiricisi, belge dönüşümünün orijinal dosyada gömülü değerli geri bildirimleri silmesi sorunuyla karşılaşıyor. Bu öğretici, GroupDocs Viewer for Java kullanarak convert Word to HTML işlemini nasıl yapacağınızı ve Word, Excel, PowerPoint, PDF ve daha fazlasını yorum verisi kaybetmeden nasıl render edeceğinizi adım adım gösteriyor.

GroupDocs Viewer’ın üretim‑hazır bir seçenek olmasının nedenlerini, ortamı nasıl kuracağınızı, ihtiyacınız olan tam kodu ve büyük dosyalarda bile performansı yüksek tutmak için kanıtlanmış ipuçlarını keşfedeceksiniz.

Yorumlu Belgeleri GroupDocs.Viewer for Java ile Render Et

Render Documents with Comments with GroupDocs.Viewer for Java

Bu öğreticide öğrenecekleriniz:

  • Tam GroupDocs Viewer kurulumu ve yapılandırması
  • Yorumlar korunarak adım adım convert Word to HTML
  • Yaygın sorun giderme çözümleri ve kaçınılması gereken tuzaklar
  • Gerçek dünya uygulama desenleri ve en iyi uygulamalar
  • Üretim kullanımı için performans optimizasyon teknikleri

Hızlı Yanıtlar

  • GroupDocs Viewer Word’ü HTML’ye dönüştürebilir mi? Evet—tek bir kod satırıyla HTML render’ı ve yorum desteği etkinleştirilir.
  • Yorumlar HTML çıktısında kalır mı? Kesinlikle—setRenderComments(true) her bir yorum ve ek açıklamayı korur.
  • Hangi Java sürümü gereklidir? JDK 8 veya üzeri.
  • Üretim için lisans gerekli mi? Tam lisans su işaretlerini kaldırır ve tüm özelliklerin kilidini açar.
  • Render hızını nasıl artırabilirsiniz? Belirli sayfaları render edin, dış kaynakları kullanın ve JVM heap boyutunu artırın.

“convert word to html” yorumlu olarak ne demektir?

“Convert Word to HTML” bir Microsoft Word .docx dosyasını, orijinal düzeni, stilini ve gömülü yorumları koruyarak web‑hazır bir HTML belgesine dönüştürmek anlamına gelir. Bu süreç, tarayıcıların belgeyi yazarların istediği gibi, inceleme geri bildirimleriyle birlikte görüntülemesini sağlar.

Neden GroupDocs Viewer for Java?

Kodlamaya başlamadan önce, GroupDocs Viewer’ın Java tabanlı belge render’ı için neden tercih edilen kütüphane olduğunu inceleyelim:

  • 170+ desteklenen format – kütüphane DOCX’ten CAD dosyalarına kadar her şeyi yönetir, böylece tüm dönüşüm ihtiyaçlarınız için tek bir bağımlılık elde edersiniz.
  • Üçüncü‑taraf Office kurulumu gerekmez – Microsoft Office, LibreOffice veya diğer ağır çalışma ortamlarına ihtiyaç duymadan herhangi bir OS üzerinde çalışır.
  • Biçimlendirme ve ek açıklamaları korur – yorumlar, dipnotlar ve değişiklik izleme, dönüşüm sırasında bozulmadan kalır.
  • Hızlı, hafif motor – tipik 100‑sayfalık belgeler standart 4‑çekirdek sunucuda 2 saniyeden kısa sürede render edilir.
  • Kapsamlı dokümantasyon ve aktif topluluk – örnekler, forumlar ve hızlı destek, bir sorunla karşılaştığınızda yanınızdadır.

Bu Yaklaşımı Ne Zaman Kullanmalısınız

  • İnceleme notlarını göstermek zorunda olan web‑tabanlı belge görüntüleyicileri oluştururken
  • Geri bildirimin görünür kalması gereken işbirlikçi inceleme platformları geliştirirken
  • Hukuki portalarda çevrimiçi gösterim için eski sözleşmeleri dönüştürürken
  • Eğitim materyallerine eğitmen yorumları ekleyen e‑öğrenme çözümleri geliştirirken

Önkoşullar ve Ortam Kurulumu

İhtiyacınız Olanlar

  • Java Development Kit (JDK) 8+ – uygulamanızı çalıştıran runtime.
  • Maven 3.6+ – bağımlılık yönetimi ve proje derlemesi için.
  • Tercih ettiğiniz IDE – IntelliJ IDEA, Eclipse veya VS Code.
  • Yorumlu örnek belgeler – DOCX, XLSX, PPTX dosyaları içinde inceleme notları bulunan.

Geliştirme Ortamınızı Kurma

Adım 1: Java Kurulumunu Doğrulayın

Bir terminal açın ve çalıştırın:

java -version

1.8 veya daha yüksek bir sürüm dizesi görmelisiniz. Görmezseniz, resmi Oracle veya OpenJDK sitesinden en yeni JDK’yı indirin.

Adım 2: Maven Kurulumunu Kontrol Edin

Çalıştırın:

mvn -v

Maven sürümünü ve kullandığı Java sürümünü raporlamalıdır. Komut tanınmazsa Apache sitesinden Maven’ı kurun.

Adım 3: Yeni Bir Maven Projesi Oluşturun

İskelet bir proje üretmek için:

mvn archetype:generate -DgroupId=com.example.viewer -DartifactId=viewer-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Oluşturulan viewer-demo klasörüne girin; artık GroupDocs Viewer eklemeye hazırsınız.

GroupDocs.Viewer for Java Kurulumu

Bağımlılığı Eklemek

Herhangi bir GroupDocs Viewer Java öğreticisindeki ilk adım, kütüphaneyi projenize eklemektir. pom.xml dosyanıza şu yapılandırmayı ekleyin:

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

İpucu: En yeni sürüm için her zaman GroupDocs releases page adresini kontrol edin. Kütüphane düzenli güncellemeler ve hata düzeltmeleriyle aktif olarak bakımda.

Lisans Seçeneklerini Anlamak

GroupDocs, farklı proje ihtiyaçlarına uygun esnek lisanslama sunar:

  • Ücretsiz Deneme (Öğrenmek İçin İdeal): Tam özellik erişimi ve değerlendirme su işaretleriyle 30‑günlük değerlendirme.
  • Geçici Lisans (Geliştirme İçin): Su işareti olmadan genişletilmiş değerlendirme; kanıt‑konsepti projeler için ideal. GroupDocs Temporary License Page adresinden talep edin.
  • Tam Lisans (Üretim Hazır): Sınırlama ve su işareti yok, ticari kullanım izinli. GroupDocs Purchase Page adresinde bulunur.

Temel Başlatma Deseni

Bu öğreticide boyunca kullanacağınız temel desen aşağıdadır:

try (Viewer viewer = new Viewer("input.docx")) {
    // Rendering options will be set later
}

Bu Desenin Neden Çalıştığı:

  • Otomatik kaynak yönetimi bellek sızıntılarını önler.
  • İstisna yönetimi yaygın dosya erişim sorunlarını yakalar.
  • Temiz, okunabilir kod büyük projelerde bakımını kolaylaştırır.

Temel Uygulama: Yorumlu Belgeleri Render Etme

Süreci Anlamak

GroupDocs Viewer ile bir belge render edildiğinde kütüphane dört ana adım gerçekleştirir:

  1. Belge Analizi – girdi dosyasını ayrıştırır ve içsel bir temsil oluşturur.
  2. Yorum Çıkarma – her bir yorum, dipnot ve ek açıklamayı belirler.
  3. HTML Oluşturma – orijinal düzeni yansıtan temiz, standart‑uyumlu HTML üretir.
  4. Kaynak Yönetimi – görüntüler, CSS ve fontları ya satıriçi ya da dış dosya olarak paketler.

Adım Adım Uygulama

Adım 1: Dosya Yollarını Ayarlayın

Erken aşamada giriş ve çıkış konumlarını düzenleyerek yol hatalarını önleyin:

Path inputPath = Paths.get("documents/sample-with-comments.docx");
Path outputDir = Paths.get("output/html");
Files.createDirectories(outputDir);

Bu Yaklaşımın Nedeni:

  • java.nio.file.Path API’si, java.io.File‘a göre daha güvenilir.
  • Açıklayıcı değişken adları hata ayıklamayı kolaylaştırır.
  • Çıktı desenindeki {0} yer tutucusu sayfa numaralarıyla otomatik olarak değiştirilir.

Adım 2: HTML Render Seçeneklerini Yapılandırın

İşte sihir burada gerçekleşir. GroupDocs’a belgeyi nasıl render edeceğimizi söylüyoruz:

HtmlViewOptions belgeyi HTML’ye render ederken kaynak yönetimi ve yorum render’ını yapılandırır.

HtmlViewOptions viewOptions = HtmlViewOptions.forEmbeddedResources(outputDir);
viewOptions.setRenderComments(true);   // Preserve every comment
viewOptions.setPageNumberPrefix("page_");

Ana Konfigürasyon Detayları:

  • forEmbeddedResources() CSS, görüntüler ve fontları doğrudan HTML içine gömer, çıktıyı taşınabilir kılar.
  • setRenderComments(true) convert word to html işleminin tüm inceleme notlarını korumasını sağlayan tek satırdır.
  • forExternalResources() ise varlıkları ayrı dosyalarda tutarak daha hafif bir HTML dosyası elde etmenizi sağlar.

Adım 3: Render İşlemini Gerçekleştirin

Şimdi her şeyi bir araya getiriyoruz:

Viewer belgeyi yüklemek ve render işlemlerini yürütmek için kullanılan ana sınıftır.

try (Viewer viewer = new Viewer(inputPath.toFile())) {
    viewer.view(viewOptions);
}

view çağrısı Word dosyasını okur, yorumları çıkarır, HTML sayfaları üretir ve output/html klasörüne yazar. Her sayfa page_1.html, page_2.html vb. olarak kaydedilir.

Tam Çalışan Örnek

Tüm parçaları birleştirerek yorumları koruyan bir Word belgesini HTML’ye dönüştüren tek bir çalıştırılabilir sınıf elde edersiniz. (Tam kaynak kodu resmi GitHub deposunda mevcuttur.)

Gelişmiş Yapılandırma ve Seçenekler

Dinamik Çıktı Dizinleri Oluşturma

Daha büyük uygulamalarda çıktı dizinlerini kullanıcı kimlikleri veya zaman damgalarına göre oluşturmak isteyebilirsiniz:

String userId = "12345";
Path dynamicOutput = Paths.get("output", userId, LocalDate.now().toString());
Files.createDirectories(dynamicOutput);
HtmlViewOptions dynamicOptions = HtmlViewOptions.forEmbeddedResources(dynamicOutput);

Yaygın Sorunlar ve Sorun Giderme

Sorun 1: “File Not Found” Hataları

Giriş yolunun mutlak ya da çalışma dizinine göre göreli olduğundan emin olun ve dosya izinlerini kontrol edin. Path nesneleri, yaygın string‑birleştirme hatalarını önler.

Sorun 2: Yorumlar Çıktıda Görünmüyor

setRenderComments(true) çağrısının viewer.view()‘den önce yapıldığını iki kez kontrol edin. Ayrıca kaynak belgenin gerçekten yorum içerdiğinden emin olun; viewer.getDocumentInfo().getComments() ile inceleyebilirsiniz.

Sorun 3: Büyük Belgelerde Bellek Hataları

GroupDocs Viewer veri akışı sağlar, ancak çok büyük dosyalar (> 500 sayfa) JVM heap’ini zorlayabilir. -Xmx4g gibi heap boyutunu artırın veya yalnızca gerekli sayfaları render edin.

Sorun 4: Yavaş Render Performansı

viewer.view(pageRange, viewOptions) ile belirli sayfa aralıklarını render edin. Dış kaynaklar (forExternalResources()) HTML yükünü azaltarak tarayıcı render süresini hızlandırır.

Gerçek Dünya Uygulama Desenleri

Desen 1: Web Uygulaması Entegrasyonu

Render mantığını bir Spring Boot denetleyicisine entegre ederek HTML’yi isteğe bağlı olarak sunun:

@RestController
@RequestMapping("/api/view")
public class DocumentController {

    @GetMapping("/{id}")
    public ResponseEntity<Resource> renderDocument(@PathVariable String id) throws IOException {
        Path docPath = Paths.get("documents", id + ".docx");
        Path outDir = Files.createTempDirectory("viewer");
        HtmlViewOptions options = HtmlViewOptions.forEmbeddedResources(outDir);
        options.setRenderComments(true);
        try (Viewer viewer = new Viewer(docPath.toFile())) {
            viewer.view(options);
        }
        // Return the first HTML page as a Resource
        Path firstPage = outDir.resolve("page_1.html");
        Resource resource = new UrlResource(firstPage.toUri());
        return ResponseEntity.ok()
                .contentType(MediaType.TEXT_HTML)
                .body(resource);
    }
}

Desen 2: Çoklu Belge İşleme (Batch)

Bir klasördeki tüm Word dosyalarını dönüştürmeniz gerektiğinde, dizini döngüye alın ve aynı HtmlViewOptions örneğini yeniden kullanarak nesne oluşturma maliyetini azaltın.

Performans Optimizasyonu ve En İyi Uygulamalar

Bellek Yönetimi İpuçları

  • Her zaman try‑with‑resources kullanın Viewer örnekleri için.
  • Büyük belgeleri partiler halinde işleyin tek seferde tüm belleğe yüklemek yerine.
  • JVM heap kullanımını VisualVM gibi araçlarla izleyin ve gerektiğinde -Xmx ayarını artırın.
  • Sık erişilen belgeler için uygun önbellekleme uygulayarak tekrar tekrar render etmeyi önleyin.

Kaynak Kullanım Kılavuzları

Küçük Uygulamalar (< 100 belge/gün) için:

HtmlViewOptions options = HtmlViewOptions.forEmbeddedResources(Paths.get("output"));
options.setRenderComments(true);

Yüksek Hacimli Uygulamalar (1000+ belge/gün) için:

HtmlViewOptions options = HtmlViewOptions.forExternalResources(Paths.get("output"));
options.setRenderComments(true);
options.setCacheEnabled(true);

Önbellek Stratejileri

Render edilmiş HTML’i belge hash’iyle anahtarlanan dağıtık bir önbellekte (ör. Redis) saklayın. Bir istek geldiğinde önbelleği kontrol edin; eşleşme varsa render motorunu atlayarak HTML’i anında sunun.

GroupDocs Viewer ve Alternatifler Ne Zaman Kullanılmalı?

GroupDocs Viewer İçin İdeal Senaryolar

  • Belge Yönetim Sistemleri – çok sayıda dosya tipini ek açıklamalarla göstermek gerekir.
  • İşbirlikçi İnceleme Platformları – yorumların tüm katılımcılar tarafından görülmesi zorunludur.
  • E‑öğrenme Araçları – eğitmen notları ders slaytlarıyla birlikte gösterilir.
  • Hukuki Uygulamalar – avukat yorumlarıyla sözleşmelerin eksiksiz render edilmesi gerekir.

Alternatifleri Düşünmeniz Gereken Durumlar

  • Basit PDF Görüntüleme – yerel tarayıcı PDF görüntüleyicileri yeterli olabilir.
  • Temel Görüntü Dönüştürme – ImageIO gibi kütüphaneler daha hafiftir.
  • Saf Metin Çıkarma – Apache POI veya iText daha uygun olabilir.

Sık Sorulan Sorular

S: Belgeleri yorum olmadan render edebilir miyim?
C: Evet—setRenderComments(true) çağrısını atlayın veya false olarak ayarlayın.

S: Hangi dosya formatları yorum render’ını destekler?
C: DOC/DOCX, XLS/XLSX, PPT/PPTX, PDF ve daha fazlası dahil olmak üzere çoğu büyük format. Tam liste için official documentation adresine bakın.

S: HTML çıktısının stilini özelleştirebilir miyim?
C: Kesinlikle. HtmlViewOptions.setEmbedResources(false) ile harici CSS dosyaları oluşturabilir, ardından kendi stil sayfanızı ekleyebilirsiniz.

S: Şifre korumalı belgelerle nasıl başa çıkılır?
C: Şifreyi içeren bir LoadOptions örneği sağlayın:

LoadOptions belge yükleme parametrelerini, örneğin şifreleri, belirtmenizi sağlar.

LoadOptions loadOptions = new LoadOptions("myPassword");
try (Viewer viewer = new Viewer(inputPath.toFile(), loadOptions)) {
    viewer.view(viewOptions);
}

S: Yalnızca belirli sayfaları render etmek mümkün mü?
C: Evet—sayfa koleksiyonu kabul eden aşırı yüklü view metodunu kullanın:

PageNumber render edilecek belirli bir sayfa indeksini temsil eder.

viewer.view(new int[]{1, 3, 5}, viewOptions);

S: Büyük belgelerde render neden yavaşlıyor?
C: Büyük dosyalar daha fazla işlem süresi gerektirir. Sadece ihtiyaç duyulan sayfaları render edin, dış kaynakları kullanın, JVM heap’ini artırın ve asenkron işleme geçin.

S: Render ilerlemesini nasıl izleyebilirim?
C: GroupDocs Viewer yerleşik geri çağırma sağlamasa da, viewer.view() öncesi ve sonrası System.nanoTime() ile zamanı ölçerek süreci loglayabilirsiniz.

S: Kaynak belge bozuk olursa ne olur?
C: Kütüphane bir ViewerException fırlatır. Çağrıyı try‑catch bloğuna alıp hatayı loglayarak sorunsuz bir düşüş sağlayın.

S: GroupDocs Viewer’ı ticari bir uygulamada kullanabilir miyim?
C: Evet, ancak ticari bir lisans gereklidir. Ücretsiz deneme su işaretleri üretim için kaldırılmalıdır.

S: Kullanım limitleri var mı?
C: Kütüphane kendisi bir limit koymaz, ancak lisans sözleşmeniz kullanım kısıtlamaları içerebilir. Detaylar için sözleşmenizi inceleyin.

S: GroupDocs Viewer içeren uygulamaları yeniden dağıtabilir miyim?
C: Kendi uygulamanızı dağıtabilirsiniz, ancak GroupDocs kütüphane ikili dosyalarını yeniden dağıtamazsınız. Uyumluluk için lisans şartlarını kontrol edin.

Sonraki Adımlar ve İleri Konular

Artık convert word to html işlemini yorumları koruyarak yapma konusunda sağlam bir temele sahipsiniz. İşte uzmanlığınızı derinleştirecek birkaç yön:

  1. Su İşareti Ekleme – sayfalara marka veya gizlilik için özel su işaretleri ekleyin.
  2. Meta Veri Çıkarma – yazar, oluşturma tarihi ve sayfa sayısı gibi bilgileri viewer.getDocumentInfo() ile alın.
  3. Özel Görüntüleyiciler – PDF, elektronik tablo veya sunumlar için yorumları farklı şekilde vurgulayan özel görüntüleyiciler oluşturun.
  4. Bulut Depolama Entegrasyonu – dosyaları yerel olarak indirmeden doğrudan AWS S3, Azure Blob veya Google Drive’dan render edin.

Önerilen Öğrenme Yolu

  1. Farklı Dosya Türleriyle Deneyim – Excel, PowerPoint ve PDF dosyalarını deneyerek yorumların formatlar arası nasıl işlendiğini görün.
  2. Basit Bir Web Görüntüleyici Oluşturun – oluşturulan HTML’yi bir <iframe> veya AJAX ile yükleyen minimal bir HTML sayfası yapın.
  3. GroupDocs Ekosistemini Keşfedin – uçtan uca belge iş akışları için GroupDocs Annotation, Comparison ve Signature’ı inceleyin.
  4. Topluluğa Katılın – GroupDocs Forum üzerinden ipuçları, örnek projeler ve destek alın.

Yardım ve Destek

Resmi Kaynaklar

Topluluk Kaynakları

  • Stack Overflow (groupdocs-viewer etiketi)
  • Reddit programlama toplulukları
  • Java geliştirici Discord sunucuları

Son Güncelleme: 2026-05-21
Test Edilen Versiyon: GroupDocs.Viewer 25.2 for Java
Yazar: GroupDocs

java -version
javac -version

mvn -version

mvn archetype:generate -DgroupId=com.example.documentviewer -DartifactId=groupdocs-viewer-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

<repositories>
   <repository>
      <id>repository.groupdocs.com</id>
      <name>GroupDocs Repository</name>
      <url>https://releases.groupdocs.com/viewer/java/</url>
   </repository>
</repositories>
<dependencies>
   <dependency>
      <groupId>com.groupdocs</groupId>
      <artifactId>groupdocs-viewer</artifactId>
      <version>25.2</version>
   </dependency>
</dependencies>

import com.groupdocs.viewer.Viewer;

// The try-with-resources pattern ensures proper cleanup
try (Viewer viewer = new Viewer("path/to/your/document.docx")) {
    // All rendering operations happen here
    // Resources are automatically closed when done
} catch (Exception e) {
    System.err.println("Error rendering document: " + e.getMessage());
    e.printStackTrace();
}

import java.nio.file.Path;
import java.nio.file.Paths;

// Create a descriptive output directory
Path outputDirectory = Paths.get("rendered-documents");
Path pageFilePathFormat = outputDirectory.resolve("page_{0}.html");

import com.groupdocs.viewer.options.HtmlViewOptions;

// Create HTML options with embedded resources
HtmlViewOptions viewOptions = HtmlViewOptions.forEmbeddedResources(pageFilePathFormat);

// The crucial setting – enable comment rendering!
viewOptions.setRenderComments(true);

import com.groupdocs.viewer.Viewer;

try (Viewer viewer = new Viewer("path/to/your/document.docx")) {
    // Create output directory if it doesn't exist
    if (!outputDirectory.toFile().exists()) {
        outputDirectory.toFile().mkdirs();
    }
    
    // Perform the actual rendering
    viewer.view(viewOptions);
    
    System.out.println("Document rendered successfully!");
    System.out.println("Output location: " + outputDirectory.toAbsolutePath());
    
} catch (Exception e) {
    System.err.println("Rendering failed: " + e.getMessage());
    e.printStackTrace();
}

package com.example.documentviewer;

import com.groupdocs.viewer.Viewer;
import com.groupdocs.viewer.options.HtmlViewOptions;
import java.nio.file.Path;
import java.nio.file.Paths;

public class DocumentRenderer {
    
    public static void main(String[] args) {
        renderDocumentWithComments("sample-document.docx", "output");
    }
    
    public static void renderDocumentWithComments(String inputFile, String outputDir) {
        // Set up paths
        Path outputDirectory = Paths.get(outputDir);
        Path pageFilePathFormat = outputDirectory.resolve("page_{0}.html");
        
        // Configure rendering options
        HtmlViewOptions viewOptions = HtmlViewOptions.forEmbeddedResources(pageFilePathFormat);
        viewOptions.setRenderComments(true);
        
        // Render the document
        try (Viewer viewer = new Viewer(inputFile)) {
            // Ensure output directory exists
            outputDirectory.toFile().mkdirs();
            
            // Execute rendering
            viewer.view(viewOptions);
            
            System.out.println("✓ Document rendered with comments preserved");
            System.out.println("📂 Output directory: " + outputDirectory.toAbsolutePath());
            
        } catch (Exception e) {
            System.err.println("❌ Rendering failed: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

import java.nio.file.Path;
import java.nio.file.Paths;

public class PathManager {
    
    /**
     * Creates a structured output path based on document name and timestamp
     */
    public static Path getOutputDirectoryPath(String documentName) {
        String timestamp = String.valueOf(System.currentTimeMillis());
        String cleanDocName = documentName.replaceAll("[^a-zA-Z0-9]", "_");
        
        return Paths.get("rendered-docs")
                   .resolve(cleanDocName)
                   .resolve(timestamp);
    }
    
    /**
     * Simple output directory for basic use cases
     */
    public static Path getSimpleOutputPath(String folderName) {
        return Paths.get("output").resolve(folderName);
    }
}

// Always check if file exists before processing
Path inputPath = Paths.get("your-document.docx");
if (!inputPath.toFile().exists()) {
    throw new IllegalArgumentException("Input file not found: " + inputPath.toAbsolutePath());
}

// Check if file is readable
if (!inputPath.toFile().canRead()) {
    throw new IllegalArgumentException("Cannot read input file: " + inputPath.toAbsolutePath());
}

HtmlViewOptions viewOptions = HtmlViewOptions.forEmbeddedResources(pageFilePathFormat);
// This line is crucial – don't forget it!
viewOptions.setRenderComments(true);

// For debugging, you can verify the setting:
System.out.println("Comments enabled: " + viewOptions.isRenderComments());

// Increase JVM heap size when running
// java -Xmx2g -Xms1g YourApplication

// Or process documents page by page for very large files
HtmlViewOptions viewOptions = HtmlViewOptions.forEmbeddedResources(pageFilePathFormat);
viewOptions.setRenderComments(true);

// Render only specific pages if needed
viewer.view(viewOptions, 1, 2, 3); // Renders only pages 1, 2, and 3

// Use external resources for faster processing of multiple pages
HtmlViewOptions viewOptions = HtmlViewOptions.forExternalResources(
    pageFilePathFormat, 
    "resources/page_{0}/", 
    "resources/page_{0}/{0}"
);

// Enable caching if processing the same document multiple times
// (Note: Implement caching at application level)

@RestController
@RequestMapping("/api/documents")
public class DocumentController {
    
    @PostMapping("/render")
    public ResponseEntity<String> renderDocument(
            @RequestParam("file") MultipartFile file) {
        
        try {
            // Save uploaded file temporarily
            Path tempFile = Files.createTempFile("upload", ".tmp");
            file.transferTo(tempFile.toFile());
            
            // Render with comments
            String outputDir = renderDocumentWithComments(
                tempFile.toString(), 
                "web-output"
            );
            
            return ResponseEntity.ok("Document rendered: " + outputDir);
            
        } catch (Exception e) {
            return ResponseEntity.badRequest()
                .body("Rendering failed: " + e.getMessage());
        }
    }
}

public class BatchDocumentProcessor {
    
    public void processFolderWithComments(String inputFolder) {
        File folder = new File(inputFolder);
        File[] files = folder.listFiles((dir, name) -> 
            name.toLowerCase().endsWith(".docx") || 
            name.toLowerCase().endsWith(".xlsx") ||
            name.toLowerCase().endsWith(".pptx")
        );
        
        if (files == null) return;
        
        for (File file : files) {
            try {
                String outputDir = file.getName().replace(".", "_") + "_output";
                renderDocumentWithComments(file.getAbsolutePath(), outputDir);
                System.out.println("✓ Processed: " + file.getName());
                
            } catch (Exception e) {
                System.err.println("❌ Failed to process " + file.getName() + ": " + e.getMessage());
            }
        }
    }
}

// Simple approach works fine
try (Viewer viewer = new Viewer(documentPath)) {
    viewer.view(viewOptions);
}

public class DocumentRenderingService {
    private final ExecutorService executorService = 
        Executors.newFixedThreadPool(4); // Limit concurrent renderings
    
    public CompletableFuture<String> renderAsync(String documentPath) {
        return CompletableFuture.supplyAsync(() -> {
            try (Viewer viewer = new Viewer(documentPath)) {
                // Rendering logic here
                return "success";
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }, executorService);
    }
}

public class CachedDocumentRenderer {
    private final Map<String, String> renderCache = new ConcurrentHashMap<>();
    
    public String renderWithCaching(String documentPath) {
        String cacheKey = generateCacheKey(documentPath);
        
        return renderCache.computeIfAbsent(cacheKey, key -> {
            // Only render if not already cached
            return performActualRendering(documentPath);
        });
    }
    
    private String generateCacheKey(String documentPath) {
        // Include file modification time in cache key
        File file = new File(documentPath);
        return documentPath + "_" + file.lastModified();
    }
}

LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your-password");
try (Viewer viewer = new Viewer("protected-doc.docx", loadOptions)) {
    // Render as usual
}

viewer.view(viewOptions, 1, 3, 5); // Renders only pages 1, 3, and 5

System.out.println("Starting render for: " + documentName);
long startTime = System.currentTimeMillis();
viewer.view(viewOptions);
long endTime = System.currentTimeMillis();
System.out.println("Rendering completed in: " + (endTime - startTime) + "ms");

try (Viewer viewer = new Viewer(documentPath)) {
    viewer.view(viewOptions);
} catch (CorruptOrDamagedFileException e) {
    System.err.println("Document is corrupted: " + e.getMessage());
} catch (Exception e) {
    System.err.println("General error: " + e.getMessage());
}

İlgili Öğreticiler