Hoe PDF Voorvertonen in Java – PNG Miniaturen Maken (2025 Gids)
Heb je ooit moeten weten how to preview PDF in Java zonder dat gebruikers het volledige bestand moeten downloaden? Of je nu een documentbeheersysteem bouwt, een bestandsbrowser maakt, of gewoon gebruikers een voorproefje van de inhoud wilt geven, preview pdf java is een game‑changer.
Als je snel preview pdf java bestanden wilt bekijken, laat deze gids je precies zien hoe. Het punt is: handmatig miniaturen of voorvertoningen maken kan een nachtmerrie zijn. Je zou verschillende bibliotheken nodig hebben voor verschillende bestandstypen, diverse formaten moeten afhandelen en worstelen met randgevallen. Daar komt GroupDocs.Annotation for Java om de hoek – het is als een Zwitsers zakmes voor het genereren van documentvoorvertoningen.
In deze tutorial leer je hoe je hoogwaardige PNG‑voorvertoningen maakt van praktisch elk documenttype met slechts een paar regels Java‑code. We behandelen alles van basisconfiguratie tot geavanceerde optimalisatietechnieken, plus praktijkvoorbeelden die je direct in je projecten kunt gebruiken.
Wat je onder de knie krijgt:
- GroupDocs.Annotation voor Java instellen (op de juiste manier)
- Klaarheldere PNG‑voorvertoningen genereren met minimale code
- Voorvertoningsopties fijn afstemmen voor verschillende use‑cases
- Veelvoorkomende problemen afhandelen voordat ze zich voordoen
- Prestatie‑optimalisatie voor productieomgevingen
Klaar om te transformeren hoe je applicatie documentvoorvertoningen afhandelt? Laten we beginnen!
Quick Answers
- Welke bibliotheek maakt preview pdf java? GroupDocs.Annotation for Java
- Hoeveel regels code zijn nodig? Ongeveer 10–15 regels voor een basisvoorvertoning
- Welk beeldformaat wordt aanbevolen? PNG voor verliesvrije kwaliteit
- Kan ik meerdere pagina’s tegelijk voorvertonen? Ja, specificeer paginanummers in
PreviewOptions - Is een licentie vereist voor productie? Ja, een commerciële licentie verwijdert watermerken
Wat is how to preview PDF in Java?
how to preview pdf verwijst naar het proces waarbij elke pagina van een PDF (of een ander ondersteund document) wordt gerenderd als een afbeelding—meestal PNG of JPEG—met Java‑code. Hiermee kun je documentminiaturen weergeven in web‑apps, mobiele apps of desktop‑tools zonder dat gebruikers het originele bestand moeten downloaden of openen.
Waarom GroupDocs.Annotation gebruiken voor PDF‑voorvertoning generatie?
Het mooie van GroupDocs.Annotation is dat het al het zware werk doet – je hoeft je geen zorgen te maken of je nu met een PDF, Word‑document, Excel‑werkblad of PowerPoint‑presentatie werkt. Eén API, alle formaten. Het kan ook convert document to image formaten zoals PNG, JPEG, BMP en meer, waardoor het perfect is voor elk visueel voorvertoningsscenario.
Wanneer deze functie te gebruiken
Voordat we in de code duiken, laten we bespreken wanneer het genereren van documentpagina‑voorvertoningen echt uitblinkt. Je zult dit enorm nuttig vinden als je werkt aan:
- Document Management Systems – Gebruikers kunnen snel door bestanden bladeren zonder elk bestand te openen. Denk aan hoe Google Drive documentvoorvertoningen toont – dat is precies wat we hier bouwen.
- E‑commerce Platforms – Digitale producten verkopen zoals eBooks, sjablonen of rapporten? Voorbeeldafbeeldingen helpen klanten te zien wat ze kopen, wat de conversieratio aanzienlijk kan verhogen.
- Legal Software – Advocaten en paralegals moeten vaak snel specifieke pagina’s uit contracten, getuigenissen of dossiers raadplegen. Voorvertoningsminiaturen maken dit proces bliksemsnel.
- Educational Platforms – Studenten kunnen hoofdstukken, opdrachten of referentiematerialen voorvertonen voordat ze beslissen wat ze willen downloaden of bestuderen.
- Content Approval Workflows – Marketingteams, uitgevers en contentmakers kunnen documentlay-outs en inhoud in één oogopslag beoordelen zonder meerdere applicaties te openen.
Prerequisites
Laten we ervoor zorgen dat je alles hebt wat je nodig hebt voordat we gaan coderen. Maak je geen zorgen – de installatie is vrij eenvoudig.
Vereiste bibliotheken en afhankelijkheden
De ster van onze show is GroupDocs.Annotation voor Java. We gebruiken Maven om de afhankelijkheidsbeheer af te handelen, want laten we eerlijk zijn, niemand wil meer handmatig JAR‑bestanden downloaden en configureren.
Omgevingsvereisten voor installatie
- Java Development Kit (JDK): Je hebt JDK 8 of hoger nodig. Als je nog een oudere versie gebruikt, is dit een goed moment om te upgraden – je krijgt betere prestaties en beveiligingsfuncties.
- Build Tool: Maven of Gradle (we gebruiken Maven in onze voorbeelden, maar de concepten zijn gemakkelijk over te zetten)
- IDE: Hoewel je elke teksteditor kunt gebruiken, raad ik IntelliJ IDEA of Eclipse aan voor betere debugging‑ en autocomplete‑functies
Vereiste kennis
Je moet vertrouwd zijn met basis Java‑programmeren en begrijpen hoe Maven‑afhankelijkheden werken. Als je nieuw bent met Maven, geen paniek – de concepten die we gebruiken zijn vrij eenvoudig, en je kunt altijd de Maven‑quick‑start‑gids raadplegen.
Setting Up GroupDocs.Annotation for Java
Hier gaan we de handen uit de mouwen steken met de daadwerkelijke installatie. Het goede nieuws? GroupDocs maakt dit proces verrassend eenvoudig.
Maven Configuratie:
Voeg deze configuratie toe aan je pom.xml‑bestand om GroupDocs.Annotation in je project op te nemen:
<repositories>
<repository>
<id>repository.groupdocs.com</id>
<name>GroupDocs Repository</name>
<url>https://releases.groupdocs.com/annotation/java/</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>com.groupdocs</groupId>
<artifactId>groupdocs-annotation</artifactId>
<version>25.2</version>
</dependency>
</dependencies>
Pro Tip: Controleer altijd het nieuwste versienummer op de GroupDocs‑website. Ze brengen regelmatig updates uit met bugfixes en nieuwe functies.
Licentie‑acquisitie
Hier is iets belangrijks om te begrijpen over licenties. GroupDocs.Annotation is niet gratis voor commercieel gebruik, maar ze maken het gemakkelijk om te evalueren:
- Free Trial: Perfect voor testen en kleine projecten. Download van de GroupDocs releases page. De proefversie voegt watermerken toe aan je voorvertoningen, wat prima is voor ontwikkeling.
- Temporary License: Meer tijd nodig om te evalueren? Vraag er een aan op hun support forum voor een verlengde proefperiode zonder watermerken.
- Full License: Wanneer je klaar bent voor productie, bezoek de purchase page om een licentie te kopen. De prijs is redelijk gezien wat je krijgt.
Basisinitialisatie
Beginnen is zo simpel als het importeren van de benodigde klassen en het aanmaken van een Annotator‑instantie. We zullen dit in de volgende sectie in actie zien, maar het belangrijkste om te onthouden is dat GroupDocs de standaard Java‑conventies volgt – geen vreemde initialisatierituelen of complexe configuratiebestanden.
Implementation Guide: Creating Document Page Previews
Nu het leuke deel – laten we echt enkele documentvoorvertoningen genereren! Het proces is eenvoudiger dan je misschien verwacht, maar er zijn enkele nuances die het waard zijn om te begrijpen.
Understanding the Preview Generation Process
Beschouw het genereren van documentvoorvertoningen als een drie‑stappen dans:
- Configure hoe je wilt dat de voorvertoningen eruitzien en waar ze naartoe moeten gaan
- Specify welke pagina’s je wilt voorvertonen
- Generate de daadwerkelijke afbeeldingen
GroupDocs.Annotation regelt al het complexe werk op de achtergrond – formaatdetectie, paginarendering, afbeeldingoptimalisatie en bestandsuitvoer. Jij hoeft alleen maar te vertellen wat je wilt.
Step 1: Define Preview Options
Hier stel je het plan op voor je voorvertoningsgeneratie. De CreatePageStream‑interface kan in eerste instantie wat intimiderend lijken, maar hij is eigenlijk best slim – hij laat je dynamisch bepalen waar elke voorvertoningsafbeelding moet worden opgeslagen.
import com.groupdocs.annotation.Annotator;
import com.groupdocs.annotation.exception.GroupDocsException;
import com.groupdocs.annotation.options.pagepreview.CreatePageStream;
import com.groupdocs.annotation.options.pagepreview.PreviewFormats;
import com.groupdocs.annotation.options.pagepreview.PreviewOptions;
import java.io.FileOutputStream;
import java.io.OutputStream;
PreviewOptions previewOptions = new PreviewOptions(new CreatePageStream() {
@Override
public OutputStream invoke(int pageNumber) {
String fileName = "YOUR_OUTPUT_DIRECTORY/GenerateDocumentPagesPreview_" + pageNumber + ".png";
try {
return new FileOutputStream(fileName);
} catch (Exception ex) {
throw new GroupDocsException(ex); // Handle exceptions appropriately.
}
}
});
What’s happening here? De CreatePageStream‑interface wordt aangeroepen voor elke pagina die je wilt voorvertonen. De pageNumber‑parameter vertelt je welke pagina wordt verwerkt, zodat je unieke bestandsnamen kunt maken. Deze aanpak geeft je maximale flexibiliteit – je kunt bestanden opslaan in verschillende mappen, verschillende naamgevingsconventies gebruiken, of zelfs de afbeeldingen direct naar een web‑respons streamen.
Step 2: Configure Preview Options
Nu kun je fijn afstemmen hoe je voorvertoningen eruitzien en zich gedragen:
previewOptions.setResolution(85); // Set desired resolution.
previewOptions.setPreviewFormat(PreviewFormats.PNG); // Choose PNG as the output format.
previewOptions.setPageNumbers(new int[]{1, 2}); // Specify pages to generate previews for.
Resolution matters: De resolutie‑instelling beïnvloedt direct zowel de beeldkwaliteit als de bestandsgrootte. Hier is een snelle richtlijn:
- 72 DPI: Goed voor web‑miniaturen, kleine bestandsgroottes
- 96 DPI: Standaard voor de meeste webapplicaties, goede balans tussen kwaliteit en grootte
- 150 DPI: Hogere kwaliteit, geschikt voor afdrukken of gedetailleerd bekijken
- 300 DPI: Printkwaliteit, grote bestandsgroottes
Format choice: Hoewel we in dit voorbeeld PNG gebruiken (wat de beste kwaliteit biedt), ondersteunt GroupDocs ook JPEG als je kleinere bestandsgroottes nodig hebt en geen bezwaar hebt tegen enige compressie‑artefacten.
Page selection: De setPageNumbers‑methode laat je selectief kiezen welke pagina’s je wilt voorvertonen. Dit is enorm handig voor grote documenten waarbij je alleen voorvertoningen van belangrijke pagina’s nodig hebt.
Step 3: Generate the Previews
Hier gebeurt de magie:
try (Annotator annotator = new Annotator("YOUR_DOCUMENT_DIRECTORY/input.pdf")) {
annotator.getDocument().generatePreview(previewOptions);
}
Why the try‑with‑resources? Dit zorgt ervoor dat het document correct wordt gesloten na verwerking, wat cruciaal is voor geheugenbeheer en het voorkomen van bestandsvergrendelingen. GroupDocs.Annotation implementeert AutoCloseable, dus dit patroon werkt perfect.
File path gotcha: Zorg ervoor dat je invoer‑bestandspad correct is en dat het bestand daadwerkelijk bestaat. Zorg er ook voor dat de uitvoermap bestaat voordat je deze code uitvoert – GroupDocs maakt mappen niet automatisch voor je aan.
Common Pitfalls and How to Avoid Them
Memory Issues: Grote documenten kunnen veel geheugen verbruiken tijdens het genereren van voorvertoningen. Als je veel documenten of zeer grote bestanden verwerkt, overweeg dan:
- Documenten in kleinere batches verwerken
- De JVM‑heap‑grootte verhogen met de
-Xmx‑parameter - Lagere resolutie‑instellingen gebruiken voor initiële voorvertoningen
File Permissions: Zorg ervoor dat je applicatie schrijfrechten heeft op de uitvoermap. Dit is vooral belangrijk bij uitvoering in gecontaineriseerde omgevingen of op servers met strikte beveiligingsbeleid.
Format Support: Hoewel GroupDocs veel formaten ondersteunt, test altijd met jouw specifieke documenttypen. Sommige zeldzame of zeer oude formaten worden mogelijk niet ondersteund, en je wilt deze gevallen op een nette manier afhandelen.
Advanced Configuration and Best Practices
Laten we je documentvoorvertoningsgeneratie naar een hoger niveau tillen met enkele geavanceerde technieken en optimalisaties.
Dynamic File Naming Strategies
Het basisvoorbeeld toont een eenvoudige naamgevingsconventie, maar in echte applicaties heb je vaak meer geavanceerde benaderingen nodig:
PreviewOptions previewOptions = new PreviewOptions(new CreatePageStream() {
@Override
public OutputStream invoke(int pageNumber) {
// Include timestamp for cache busting
String timestamp = String.valueOf(System.currentTimeMillis());
String fileName = String.format("preview_%s_page_%d_%s.png",
documentId, pageNumber, timestamp);
String fullPath = outputDirectory + "/" + fileName;
try {
return new FileOutputStream(fullPath);
} catch (Exception ex) {
throw new GroupDocsException(ex);
}
}
});
Deze aanpak geeft je:
- Unieke bestandsnamen die niet conflicteren
- Gemakkelijke identificatie van welk document de voorvertoning behoort
- Ingebouwde cache‑busting voor webapplicaties
Batch Processing Multiple Documents
Wanneer je voorvertoningen voor meerdere documenten moet genereren, wordt efficiëntie cruciaal:
public void generatePreviewsForDocuments(List<String> documentPaths, String outputDir) {
for (String docPath : documentPaths) {
try (Annotator annotator = new Annotator(docPath)) {
String docName = Paths.get(docPath).getFileName().toString();
PreviewOptions options = new PreviewOptions(pageNumber -> {
String fileName = String.format("%s/%s_page_%d.png",
outputDir, docName, pageNumber);
try {
return new FileOutputStream(fileName);
} catch (Exception ex) {
throw new GroupDocsException(ex);
}
});
options.setResolution(96);
options.setPreviewFormat(PreviewFormats.PNG);
annotator.getDocument().generatePreview(options);
} catch (Exception ex) {
// Log error but continue processing other documents
System.err.println("Failed to process " + docPath + ": " + ex.getMessage());
}
}
}
Performance Optimization Tips
Memory Management: Voor productie‑applicaties, monitor het geheugenverbruik en overweeg het implementeren van opruimstrategieën:
// Force garbage collection after processing large batches
System.gc();
Parallel Processing: Voor grote documentsets, overweeg parallelle verwerking (maar wees voorzichtig met geheugenverbruik):
documentPaths.parallelStream().forEach(this::generatePreviewForDocument);
Caching Strategy: Implementeer intelligente caching om onnodig opnieuw genereren van voorvertoningen te voorkomen:
- Controleren of voorvertoningsbestanden al bestaan en nieuwer zijn dan het bron‑document
- Bestand‑modificatietijdstempels gebruiken om te bepalen of regeneratie nodig is
- Overwegen het opslaan van voorvertoningsmetadata in een database voor snellere zoekopdrachten
Real-World Integration Examples
Laten we bekijken hoe deze voorvertoningsgeneratie past in daadwerkelijke applicaties die je mogelijk bouwt.
Web Application Integration
Zo kun je dit integreren in een Spring Boot webapplicatie:
@RestController
public class DocumentPreviewController {
@GetMapping("/api/documents/{id}/preview/{pageNumber}")
public ResponseEntity<byte[]> getDocumentPreview(
@PathVariable String id,
@PathVariable int pageNumber) {
// Check if preview already exists
String previewPath = getPreviewPath(id, pageNumber);
if (Files.exists(Paths.get(previewPath))) {
byte[] imageBytes = Files.readAllBytes(Paths.get(previewPath));
return ResponseEntity.ok()
.contentType(MediaType.IMAGE_PNG)
.body(imageBytes);
}
// Generate preview if it doesn't exist
generatePreviewForPage(id, pageNumber);
// Return the generated preview
byte[] imageBytes = Files.readAllBytes(Paths.get(previewPath));
return ResponseEntity.ok()
.contentType(MediaType.IMAGE_PNG)
.body(imageBytes);
}
}
Document Management System Integration
Voor enterprise documentbeheersystemen wil je mogelijk voorvertoningen asynchroon genereren:
@Service
public class DocumentPreviewService {
@Async
public CompletableFuture<List<String>> generatePreviewsAsync(String documentPath) {
List<String> previewPaths = new ArrayList<>();
try (Annotator annotator = new Annotator(documentPath)) {
// Get total page count first
int pageCount = annotator.getDocument().getPages().size();
PreviewOptions options = new PreviewOptions(pageNumber -> {
String previewPath = generatePreviewPath(documentPath, pageNumber);
previewPaths.add(previewPath);
try {
return new FileOutputStream(previewPath);
} catch (Exception ex) {
throw new GroupDocsException(ex);
}
});
// Generate previews for all pages
int[] allPages = IntStream.rangeClosed(1, pageCount).toArray();
options.setPageNumbers(allPages);
options.setResolution(150);
annotator.getDocument().generatePreview(options);
}
return CompletableFuture.completedFuture(previewPaths);
}
}
Performance Considerations and Optimization
Wanneer je te maken hebt met documentvoorvertoningsgeneratie in productie, worden prestaties cruciaal. Hier zijn de belangrijkste aandachtspunten:
Memory Management Strategies
Document Size Limits: Grote documenten kunnen snel het beschikbare geheugen opslokken. Overweeg het implementeren van grootte‑controles:
File documentFile = new File(documentPath);
long fileSizeInMB = documentFile.length() / (1024 * 1024);
if (fileSizeInMB > 50) { // Adjust threshold based on your server capacity
// Process with lower resolution or in smaller chunks
previewOptions.setResolution(72);
}
Resource Cleanup: Gebruik altijd try‑with‑resources en overweeg expliciete opruiming voor langdurige processen:
try (Annotator annotator = new Annotator(documentPath)) {
// Generate previews
annotator.getDocument().generatePreview(previewOptions);
} // Automatic cleanup happens here
Scaling for High‑Volume Applications
Queue‑Based Processing: Voor applicaties die veel documenten moeten verwerken, overweeg het gebruik van een berichtwachtrij:
@Component
public class PreviewGenerationWorker {
@RabbitListener(queues = "preview-generation-queue")
public void processPreviewRequest(PreviewRequest request) {
try {
generateDocumentPreviews(request.getDocumentPath(), request.getOutputDir());
} catch (Exception ex) {
// Handle errors, potentially retry or send to dead letter queue
log.error("Failed to generate previews for {}", request.getDocumentPath(), ex);
}
}
}
Caching Strategies: Implementeer intelligente caching om onnodige regeneratie te vermijden:
public boolean shouldRegeneratePreview(String documentPath, String previewPath) {
try {
Path docPath = Paths.get(documentPath);
Path prevPath = Paths.get(previewPath);
if (!Files.exists(prevPath)) {
return true; // Preview doesn't exist
}
FileTime docModified = Files.getLastModifiedTime(docPath);
FileTime previewModified = Files.getLastModifiedTime(prevPath);
return docModified.compareTo(previewModified) > 0; // Doc is newer
} catch (Exception ex) {
return true; // When in doubt, regenerate
}
}
Resolution and Quality Optimization
Adaptive Resolution: Pas de resolutie aan op basis van het beoogde gebruik:
public int getOptimalResolution(PreviewUsage usage) {
switch (usage) {
case THUMBNAIL: return 72;
case WEB_DISPLAY: return 96;
case DETAILED_REVIEW: return 150;
case PRINT_QUALITY: return 300;
default: return 96;
}
}
Troubleshooting Common Issues
Zelfs met de beste configuratie kom je af en toe problemen tegen. Hier zijn de meest voorkomende problemen en hun oplossingen:
File Access and Permission Issues
Problem: “Access denied” of “File not found” fouten
Solution:
- Controleer of bestandspaden correct zijn en bestanden bestaan
- Controleer of je applicatie leesrechten heeft op bron‑documenten
- Zorg voor schrijfrechten op uitvoermappen
- Controleer op Linux/Unix‑systemen de bestands‑eigendom en -rechten
Memory and Performance Problems
Problem: OutOfMemoryError of trage verwerking
Solutions:
- Verhoog de JVM‑heap‑grootte:
-Xmx2048m - Verwerk minder pagina’s tegelijk
- Gebruik lagere resolutie‑instellingen voor grote documenten
- Implementeer document‑grootte‑limieten (zie code‑fragment hierboven)
Format‑Specific Issues
Problem: Sommige documenten genereren geen correcte voorvertoningen
Solutions:
- Controleer of het document niet corrupt is door het handmatig te openen
- Controleer de ondersteunde formatenlijst van GroupDocs.Annotation (de bibliotheek ondersteunt meer dan 50 formaten)
- Wachtwoord‑beveiligde documenten kunnen extra afhandeling vereisen (zie FAQ)
- Zorg dat alle vereiste lettertypen beschikbaar zijn op de server
Output Quality Problems
Problem: Vage of gepixelde voorvertoningsafbeeldingen
Solutions:
- Verhoog de resolutie‑instellingen (let op geheugenverbruik)
- Voor tekst‑zware documenten werkt PNG over het algemeen beter dan JPEG
- Zorg dat het bron‑document voldoende kwaliteit heeft
Frequently Asked Questions
Q: Welke bestandsformaten ondersteunt GroupDocs.Annotation voor voorvertoningsgeneratie?
A: Meer dan 50 formaten worden ondersteund, waaronder PDF, Word, Excel, PowerPoint, OpenDocument, gangbare beeldtypen, en CAD‑bestanden zoals DWG en DXF. De volledige lijst wordt bijgehouden in de officiële documentatie.
Q: Kan ik voorvertoningen genereren voor wachtwoord‑beveiligde documenten?
A: Ja. Gebruik de Annotator‑constructor die LoadOptions accepteert met het wachtwoord, bijvoorbeeld new Annotator(filePath, new LoadOptions(password)).
Q: Hoe ga ik om met zeer grote documenten zonder geheugen op te raken?
A: Verwerk pagina’s in kleinere batches, gebruik lagere resolutie voor initiële miniaturen, vergroot de JVM‑heap‑grootte, en overweeg het streamen van voorvertoningen in plaats van het volledige document in het geheugen te laden.
Q: Is het mogelijk om de uitvoermap‑structuur dynamisch aan te passen?
A: Absoluut. De CreatePageStream‑interface geeft je volledige controle over waar bestanden worden opgeslagen. Je kunt organiseren op datum, documenttype, gebruiker, of andere criteria door de padlogica in invoke aan te passen.
Q: Kan ik voorvertoningen genereren in andere formaten dan PNG?
A: Ja. GroupDocs.Annotation ondersteunt JPEG, BMP en andere beeldformaten. Wissel van formaat met previewOptions.setPreviewFormat(PreviewFormats.JPEG) als je kleinere bestandsgroottes nodig hebt.
Conclusion
Je hebt nu de kunst onder de knie gekregen van het genereren van preview pdf java miniaturen met GroupDocs.Annotation! Deze krachtige functie kan transformeren hoe gebruikers met documenten omgaan in je applicaties, of je nu een eenvoudige bestandsbrowser bouwt of een complex enterprise documentbeheersysteem.
Belangrijkste inzichten:
- GroupDocs.Annotation stelt je in staat om hoogwaardige PNG‑voorvertoningen te maken met slechts een paar regels Java‑code
- Flexibele configuratie laat je resolutie, formaat en paginaselectie aanpassen aan elke use‑case
- Prestatie‑gerichte tips (geheugenbeheer, caching, async verwerking) houden je app responsief op schaal
- Robuuste foutafhandeling en troubleshooting‑richtlijnen helpen je veelvoorkomende valkuilen te vermijden
Klaar om verder te gaan? Ontdek de extra mogelijkheden van GroupDocs.Annotation, zoals het toevoegen van annotaties, tekst extraheren, of converteren tussen formaten. De official documentation biedt uitgebreide handleidingen voor al deze functies.
Volgende stappen:
- Clone een voorbeeldproject en probeer de code met je eigen PDF‑s, Word‑documenten of Excel‑bestanden.
- Experimenteer met verschillende resoluties en formaten om de optimale balans voor je UI te vinden.
- Integreer de voorvertoningsgeneratie in een web‑endpoint (zoals getoond) en cache de resultaten voor snelle volgende loads.
Veel plezier met coderen, en geniet van de soepelere documentervaringen die je zult leveren!
Last Updated: 2026-03-19
Tested With: GroupDocs.Annotation 25.2 for Java
Author: GroupDocs
