Générateur d’aperçu de page de document Java - Créez des miniatures PNG (Guide 2025)

Introduction

Vous avez déjà eu besoin de montrer aux utilisateurs un aperçu rapide d’un document sans les obliger à télécharger le fichier complet ? Que vous construisiez un système de gestion de documents, créiez un explorateur de fichiers, ou simplement souhaitiez offrir aux utilisateurs un avant‑goût du contenu, preview pdf java est une révolution.

Si vous devez rapidement preview pdf java des fichiers, ce guide vous montre exactement comment faire. Le problème, c’est que créer manuellement des miniatures ou des aperçus peut être un cauchemar. Vous auriez besoin de bibliothèques différentes pour chaque type de fichier, gérer divers formats et vous débattre avec des cas limites. C’est là que GroupDocs.Annotation for Java intervient – c’est comme un couteau suisse pour la génération d’aperçus de documents.

Dans ce tutoriel, vous apprendrez à créer des aperçus PNG de haute qualité à partir de pratiquement n’importe quel type de document en utilisant seulement quelques lignes de code Java. Nous couvrirons tout, de la configuration de base aux techniques d’optimisation avancées, ainsi que des exemples concrets que vous pouvez réellement utiliser dans vos projets.

Ce que vous maîtriserez :

  • Configurer GroupDocs.Annotation for Java (de la bonne manière)
  • Générer des aperçus PNG d’une netteté cristalline avec un code minimal
  • Affiner les options d’aperçu pour différents cas d’utilisation
  • Gérer les problèmes courants avant qu’ils ne deviennent des problèmes
  • Optimisation des performances pour les environnements de production

Prêt à transformer la façon dont votre application gère les aperçus de documents ? Plongeons‑y !

Quick Answers

  • Quelle bibliothèque crée preview pdf java ? GroupDocs.Annotation for Java
  • Combien de lignes de code sont nécessaires ? Environ 10–15 lignes pour un aperçu de base
  • Quel format d’image est recommandé ? PNG pour une qualité sans perte
  • Puis‑je prévisualiser plusieurs pages à la fois ? Oui, spécifiez les numéros de page dans PreviewOptions
  • Une licence est‑elle requise pour la production ? Oui, une licence commerciale supprime les filigranes

Qu’est‑ce que preview pdf java ?

preview pdf java désigne le processus de rendu de chaque page d’un PDF (ou d’un autre document pris en charge) sous forme d’image — généralement PNG ou JPEG — en utilisant du code Java. Cela vous permet d’afficher des miniatures de documents dans des applications web, mobiles ou de bureau sans obliger les utilisateurs à télécharger ou ouvrir le fichier original.

Quand utiliser cette fonctionnalité

Avant de plonger dans le code, parlons du moment où la génération d’aperçus de pages de documents brille vraiment. Vous trouverez cela extrêmement utile si vous travaillez sur :

Systèmes de gestion de documents – Les utilisateurs peuvent parcourir rapidement les fichiers sans en ouvrir chacun. Pensez à la façon dont Google Drive vous montre des aperçus de documents – c’est exactement ce que nous construisons ici.

Plateformes de commerce électronique – Vous vendez des produits numériques comme des eBooks, des modèles ou des rapports ? Les images d’aperçu aident les clients à voir ce qu’ils achètent, ce qui peut augmenter considérablement le taux de conversion.

Logiciels juridiques – Les avocats et les assistants juridiques ont souvent besoin de référencer rapidement des pages spécifiques de contrats, dépositions ou dossiers. Les miniatures d’aperçu rendent ce processus ultra‑rapide.

Plateformes éducatives – Les étudiants peuvent prévisualiser les pages de manuels, devoirs ou documents de référence avant de décider quoi télécharger ou étudier.

Flux de travail d’approbation de contenu – Les équipes marketing, éditeurs et créateurs de contenu peuvent examiner la mise en page et le contenu des documents d’un coup d’œil sans ouvrir plusieurs applications.

La beauté de GroupDocs.Annotation réside dans le fait qu’il gère toute la lourde tâche – vous n’avez pas à vous soucier de savoir si vous traitez un PDF, un document Word, une feuille de calcul Excel ou une présentation PowerPoint. Une API, tous les formats.

Prerequisites

Assurons‑nous que vous avez tout ce dont vous avez besoin avant de commencer à coder. Pas d’inquiétude – la configuration est assez simple.

Bibliothèques et dépendances requises

La vedette principale de notre démonstration est GroupDocs.Annotation for Java. Nous utiliserons Maven pour gérer les dépendances car, soyons honnêtes, personne ne veut télécharger et configurer manuellement des fichiers JAR de nos jours.

Exigences de configuration de l’environnement

  • Java Development Kit (JDK) : Vous avez besoin du JDK 8 ou supérieur. Si vous êtes encore sur une version plus ancienne, c’est le moment idéal pour mettre à jour – vous bénéficierez de meilleures performances et de fonctionnalités de sécurité.
  • Outil de construction : Maven ou Gradle (nous utiliserons Maven dans nos exemples, mais les concepts se traduisent facilement)
  • IDE : Bien que vous puissiez utiliser n’importe quel éditeur de texte, je recommande IntelliJ IDEA ou Eclipse pour un meilleur débogage et des fonctionnalités d’autocomplétion.

Prérequis de connaissances

Vous devez être à l’aise avec la programmation Java de base et comprendre le fonctionnement des dépendances Maven. Si vous êtes nouveau avec Maven, ne paniquez pas – les concepts que nous utiliserons sont assez simples, et vous pouvez toujours vous référer au guide de démarrage de Maven.

Setting Up GroupDocs.Annotation for Java

C’est ici que nous nous mettons les mains dans le cambouis avec la configuration réelle. La bonne nouvelle ? GroupDocs rend ce processus étonnamment indolore.

Configuration Maven :
Ajoutez cette configuration à votre fichier pom.xml pour inclure GroupDocs.Annotation dans votre projet :

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

Astuce : Vérifiez toujours le numéro de version le plus récent sur le site Web de GroupDocs. Ils publient régulièrement des mises à jour avec des corrections de bugs et de nouvelles fonctionnalités.

Acquisition de licence

Voici un point important à comprendre concernant la licence. GroupDocs.Annotation n’est pas gratuit pour une utilisation commerciale, mais ils facilitent l’évaluation :

  • Essai gratuit : Parfait pour les tests et les petits projets. Téléchargez depuis la page des versions GroupDocs. La version d’essai ajoute des filigranes à vos aperçus, ce qui convient pour le développement.
  • Licence temporaire : Besoin de plus de temps pour évaluer ? Demandez‑en une sur leur forum de support pour une période d’essai prolongée sans filigranes.
  • Licence complète : Lorsque vous êtes prêt pour la production, visitez la page d’achat pour acheter une licence. Le prix est raisonnable compte tenu de ce que vous obtenez.

Initialisation de base

Commencer est aussi simple que d’importer les classes nécessaires et de créer une instance Annotator. Nous verrons cela en action dans la section suivante, mais l’essentiel à retenir est que GroupDocs suit les conventions Java standard – pas de rituels d’initialisation étranges ou de fichiers de configuration complexes.

Guide d’implémentation : création d’aperçus de pages de documents

Passons à la partie amusante – générons réellement des aperçus de documents ! Le processus est plus simple que vous ne le pensez, mais il y a quelques nuances à comprendre.

Comprendre le processus de génération d’aperçus

Considérez la génération d’aperçus de documents comme une danse en trois étapes :

  1. Configurer comment vous voulez que les aperçus apparaissent et où ils doivent être enregistrés
  2. Spécifier quelles pages vous souhaitez prévisualiser
  3. Générer les images réelles

GroupDocs.Annotation gère toute la complexité en arrière‑plan – détection du format, rendu des pages, optimisation des images et sortie des fichiers. Vous n’avez qu’à lui indiquer ce que vous voulez.

Étape 1 : définir les options d’aperçu

C’est ici que vous définissez le plan de génération de vos aperçus. L’interface CreatePageStream peut sembler un peu intimidante au premier abord, mais elle est en fait très astucieuse – elle vous permet de décider dynamiquement où chaque image d’aperçu doit être enregistrée.

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

Que se passe‑t‑il ici ? L’interface CreatePageStream est appelée pour chaque page que vous souhaitez prévisualiser. Le paramètre pageNumber indique quelle page est en cours de traitement, vous permettant de créer des noms de fichiers uniques. Cette approche vous offre une flexibilité maximale – vous pouvez enregistrer les fichiers dans différents répertoires, utiliser des conventions de nommage différentes, ou même diffuser les images directement dans une réponse web.

Étape 2 : configurer les options d’aperçu

Vous pouvez maintenant affiner l’apparence et le comportement de vos aperçus :

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.

La résolution compte : le paramètre de résolution influence directement la qualité de l’image et la taille du fichier. Voici un guide rapide :

  • 72 DPI : Bon pour les miniatures web, petite taille de fichier
  • 96 DPI : Standard pour la plupart des applications web, bon équilibre qualité/taille
  • 150 DPI : Qualité supérieure, adaptée à l’impression ou à la visualisation détaillée
  • 300 DPI : Qualité d’impression, grande taille de fichier

Choix du format : Bien que nous utilisions PNG dans cet exemple (qui offre la meilleure qualité), GroupDocs prend également en charge JPEG si vous avez besoin de tailles de fichier plus petites et que vous ne craignez pas les artefacts de compression.

Sélection des pages : La méthode setPageNumbers vous permet de choisir précisément les pages à prévisualiser. C’est extrêmement utile pour les gros documents où vous ne avez besoin que d’aperçus de pages clés.

Étape 3 : générer les aperçus

C’est ici que la magie opère :

try (Annotator annotator = new Annotator("YOUR_DOCUMENT_DIRECTORY/input.pdf")) {
    annotator.getDocument().generatePreview(previewOptions);
}

Pourquoi le try‑with‑resources ? Cela garantit que le document est correctement fermé après le traitement, ce qui est crucial pour la gestion de la mémoire et la prévention des verrous de fichiers. GroupDocs.Annotation implémente AutoCloseable, donc ce modèle fonctionne parfaitement.

Attention au chemin de fichier : Assurez‑vous que le chemin du fichier d’entrée est correct et que le fichier existe réellement. De plus, assurez‑vous que le répertoire de sortie existe avant d’exécuter ce code – GroupDocs ne crée pas automatiquement les répertoires.

Pièges courants et comment les éviter

Problèmes de mémoire : Les gros documents peuvent consommer beaucoup de mémoire pendant la génération d’aperçus. Si vous traitez de nombreux documents ou des fichiers très volumineux, envisagez :

  • Traiter les documents par lots plus petits
  • Augmenter la taille du tas JVM avec le paramètre -Xmx
  • Utiliser des réglages de résolution plus bas pour les aperçus initiaux

Permissions de fichiers : Assurez‑vous que votre application a les droits d’écriture sur le répertoire de sortie. C’est particulièrement important lors de l’exécution dans des environnements conteneurisés ou sur des serveurs avec des politiques de sécurité strictes.

Support des formats : Bien que GroupDocs prenne en charge de nombreux formats, testez toujours avec vos types de documents spécifiques. Certains formats rares ou très anciens peuvent ne pas être supportés, et vous devrez gérer ces cas avec grâce.

Configuration avancée et meilleures pratiques

Portons votre génération d’aperçus de documents au niveau supérieur avec quelques techniques avancées et optimisations.

Stratégies de nommage de fichiers dynamiques

L’exemple de base montre une convention de nommage simple, mais dans les applications réelles vous aurez souvent besoin d’approches plus sophistiquées :

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

Cette approche vous offre :

  • Des noms de fichiers uniques qui ne se chevauchent pas
  • Une identification facile du document auquel appartient l’aperçu
  • Un bustage de cache intégré pour les applications web

Traitement par lots de plusieurs documents

Lorsque vous devez générer des aperçus pour plusieurs documents, l’efficacité devient cruciale :

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

Conseils d’optimisation des performances

Gestion de la mémoire : Pour les applications en production, surveillez l’utilisation de la mémoire et envisagez de mettre en œuvre des stratégies de nettoyage :

// Force garbage collection after processing large batches
System.gc();

Traitement parallèle : Pour de grands ensembles de documents, envisagez le traitement parallèle (mais faites attention à l’utilisation de la mémoire) :

documentPaths.parallelStream().forEach(this::generatePreviewForDocument);

Stratégie de mise en cache : Mettez en œuvre une mise en cache intelligente pour éviter de régénérer les aperçus inutilement :

  • Vérifier si les fichiers d’aperçu existent déjà et sont plus récents que le document source
  • Utiliser les horodatages de modification des fichiers pour déterminer si une régénération est nécessaire
  • Envisager de stocker les métadonnées d’aperçu dans une base de données pour des recherches plus rapides

Exemples d’intégration réels

Voyons comment cette génération d’aperçus s’intègre dans les applications réelles que vous pourriez construire.

Intégration d’une application web

Voici comment vous pourriez intégrer cela dans une application web Spring Boot :

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

Intégration dans un système de gestion de documents

Pour les systèmes de gestion de documents d’entreprise, vous pourriez vouloir générer les aperçus de façon asynchrone :

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

Considérations de performance et optimisation

Lorsque vous gérez la génération d’aperçus de documents en production, la performance devient critique. Voici les domaines clés sur lesquels se concentrer :

Stratégies de gestion de la mémoire

Limites de taille de document : Les gros documents peuvent rapidement consommer la mémoire disponible. Envisagez de mettre en place des vérifications de taille :

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

Nettoyage des ressources : Utilisez toujours le try‑with‑resources et envisagez un nettoyage explicite pour les processus de longue durée :

try (Annotator annotator = new Annotator(documentPath)) {
    // Generate previews
    annotator.getDocument().generatePreview(previewOptions);
} // Automatic cleanup happens here

Mise à l’échelle pour les applications à haut volume

Traitement basé sur une file d’attente : Pour les applications qui doivent traiter de nombreux documents, envisagez d’utiliser une file de messages :

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

Stratégies de mise en cache : Mettez en œuvre une mise en cache intelligente pour éviter les régénérations inutiles :

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

Optimisation de la résolution et de la qualité

Résolution adaptative : Ajustez la résolution en fonction de l’usage prévu :

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

Dépannage des problèmes courants

Même avec la meilleure configuration, vous rencontrerez parfois des problèmes. Voici les problèmes les plus courants et leurs solutions :

Problèmes d’accès aux fichiers et de permissions

Problème : erreurs « Access denied » ou « File not found »
Solution :

  • Vérifier que les chemins de fichiers sont corrects et que les fichiers existent
  • S’assurer que votre application a les droits de lecture sur les documents source
  • Garantir les droits d’écriture sur les répertoires de sortie
  • Sous Linux/Unix, vérifier la propriété et les permissions des fichiers

Problèmes de mémoire et de performance

Problème : OutOfMemoryError ou traitement lent
Solutions :

  • Augmenter la taille du tas JVM : -Xmx2048m
  • Traiter moins de pages à la fois
  • Utiliser des réglages de résolution plus bas pour les gros documents
  • Mettre en œuvre des limites de taille de document (voir l’extrait de code ci‑dessus)

Problèmes spécifiques aux formats

Problème : certains documents ne génèrent pas correctement les aperçus
Solutions :

  • Vérifier que le document n’est pas corrompu en l’ouvrant manuellement
  • Consulter la liste des formats supportés par GroupDocs.Annotation (plus de 50 formats)
  • Les documents protégés par mot de passe peuvent nécessiter une prise en charge supplémentaire (voir FAQ)
  • S’assurer que toutes les polices requises sont disponibles sur le serveur

Problèmes de qualité de sortie

Problème : images d’aperçu floues ou pixelisées
Solutions :

  • Augmenter les réglages de résolution (surveiller l’utilisation de la mémoire)
  • Pour les documents très textuels, le PNG fonctionne généralement mieux que le JPEG
  • Vérifier que le document source possède une qualité suffisante

Questions fréquentes

Q : Quels formats de fichiers GroupDocs.Annotation prend‑il en charge pour la génération d’aperçus ?
R : Plus de 50 formats sont supportés, dont PDF, Word, Excel, PowerPoint, OpenDocument, les types d’image courants, ainsi que les fichiers CAD comme DWG et DXF. La liste complète est maintenue dans la documentation officielle.

Q : Puis‑je générer des aperçus pour des documents protégés par mot de passe ?
R : Oui. Utilisez le constructeur Annotator qui accepte LoadOptions avec le mot de passe, par exemple new Annotator(filePath, new LoadOptions(password)).

Q : Comment gérer des documents très volumineux sans épuiser la mémoire ?
R : Traitez les pages par lots plus petits, utilisez une résolution plus basse pour les miniatures initiales, augmentez la taille du tas JVM, et envisagez de diffuser les aperçus au lieu de charger le document entier en mémoire.

Q : Est‑il possible de personnaliser dynamiquement la structure du répertoire de sortie ?
R : Absolument. L’interface CreatePageStream vous donne le contrôle total sur l’endroit où les fichiers sont enregistrés. Vous pouvez organiser par date, type de document, utilisateur ou tout autre critère en ajustant la logique du chemin dans invoke.

Q : Puis‑je générer des aperçus dans des formats autres que PNG ?
R : Oui. GroupDocs.Annotation prend en charge JPEG, BMP et d’autres formats d’image. Changez le format avec previewOptions.setPreviewFormat(PreviewFormats.JPEG) si vous avez besoin de tailles de fichier plus petites.

Conclusion

Vous avez maintenant maîtrisé l’art de générer des miniatures preview pdf java avec GroupDocs.Annotation ! Cette fonctionnalité puissante peut transformer la façon dont les utilisateurs interagissent avec les documents dans vos applications, que vous construisiez un simple explorateur de fichiers ou un système de gestion de documents d’entreprise complexe.

Points clés :

  • GroupDocs.Annotation vous permet de créer des aperçus PNG de haute qualité avec quelques lignes de code Java
  • La configuration flexible vous laisse ajuster résolution, format et sélection de pages selon chaque cas d’utilisation
  • Les conseils d’optimisation (gestion de la mémoire, mise en cache, traitement asynchrone) maintiennent votre application réactive à grande échelle
  • Une gestion robuste des erreurs et un guide de dépannage vous aident à éviter les pièges courants

Prêt à aller plus loin ? Explorez les capacités supplémentaires de GroupDocs.Annotation comme l’ajout d’annotations, l’extraction de texte ou la conversion entre formats. La documentation officielle propose des guides complets pour toutes ces fonctionnalités.

Étapes suivantes :

  1. Clonez un projet d’exemple et testez le code avec vos propres PDF, documents Word ou fichiers Excel.
  2. Expérimentez avec différentes résolutions et formats pour trouver le compromis idéal pour votre interface.
  3. Intégrez la génération d’aperçus dans un point d’accès web (comme montré) et mettez en cache les résultats pour des chargements rapides ultérieurs.

Bon codage, et profitez des expériences documentaires plus fluides que vous offrirez !

Dernière mise à jour : 2026-01-18
Testé avec : GroupDocs.Annotation 25.2 for Java
Auteur : GroupDocs