Exemple complet fonctionnel pour supprimer les objets d’annotation d’un PDF avec REST en Node.JS

Cet exemple montre comment téléverser un PDF, supprimer toutes ses annotations et télécharger le fichier nettoyé en utilisant le GroupDocs.Annotation SDK.

const fs = require('fs');
const path = require('path');
const GroupDocsAnnotationCloud = require("@groupdocs/annotation-cloud");

// ==== Authentication =========================================================
const clientId = "YOUR_CLIENT_ID";
const clientSecret = "YOUR_CLIENT_SECRET";

const config = new GroupDocsAnnotationCloud.Configuration(clientId, clientSecret);
const annotationsApi = new GroupDocsAnnotationCloud.AnnotationsApi(config);
const storageApi = new GroupDocsAnnotationCloud.StorageApi(config);

// ==== Local & Remote file definitions =======================================
const localInputPath = path.resolve(__dirname, "input.pdf");
const localOutputPath = path.resolve(__dirname, "output.pdf");
const remoteFilePath = "input.pdf";

// ==== Main workflow ==========================================================
(async () => {
    // 1. Upload PDF to GroupDocs Cloud storage
    const fileBytes = fs.readFileSync(localInputPath);
    const uploadRequest = new GroupDocsAnnotationCloud.UploadFileRequest({
        path: remoteFilePath,
        file: fileBytes
    });
    await storageApi.uploadFile(uploadRequest);

// 2. Build FileInfo object for the uploaded PDF
    const fileInfo = new GroupDocsAnnotationCloud.FileInfo({
        filePath: remoteFilePath
    });

// 3. Retrieve all existing annotations
    const getAnnotationsRequest = new GroupDocsAnnotationCloud.GetAnnotationsRequest({
        fileInfo: fileInfo
    });
    const annotationsResult = await annotationsApi.getAnnotations(getAnnotationsRequest);
    const annotationIds = (annotationsResult.annotations || []).map(a => a.id);

// 4. Delete all annotations (if any)
    if (annotationIds.length > 0) {
        const deleteRequest = new GroupDocsAnnotationCloud.DeleteAnnotationsRequest({
            fileInfo: fileInfo,
            annotationIds: annotationIds
        });
        await annotationsApi.deleteAnnotations(deleteRequest);
    }

// 5. Download the cleaned PDF back to local storage
    const downloadRequest = new GroupDocsAnnotationCloud.DownloadFileRequest({
        path: remoteFilePath
    });
    const fileStream = await storageApi.downloadFile(downloadRequest);
    fs.writeFileSync(localOutputPath, fileStream);
    console.log(`All annotations removed. Clean file saved to ${localOutputPath}`);
})();

Note : Cet exemple de code démontre la fonctionnalité principale. Avant de l’utiliser dans votre projet, assurez‑vous de mettre à jour tous les chemins de fichiers et les valeurs de configuration pour qu’ils correspondent à votre environnement réel, vérifiez que toutes les dépendances requises sont correctement installées et testez soigneusement dans votre environnement de développement. Si vous rencontrez des problèmes, veuillez consulter la documentation officielle ou contacter l’équipe de support pour obtenir de l’aide.

Supprimer les annotations PDF via l’API REST en utilisant cURL

Ci-dessous se trouvent les commandes cURL qui exécutent le même flux de travail de suppression d’annotation via les points de terminaison REST de GroupDocs.Annotation Cloud.

# 1. Obtain an access token
curl -X POST "https://api.groupdocs.cloud/v2.0/auth/token" \
     -H "Content-Type: application/json" \
     -d "{\"client_id\":\"YOUR_CLIENT_ID\",\"client_secret\":\"YOUR_CLIENT_SECRET\"}"

# 2. Upload the source PDF
curl -X PUT "https://api.groupdocs.cloud/v2.0/storage/file/input.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/pdf" \
     --data-binary "@input.pdf"

# 3. Retrieve annotation IDs
curl -X GET "https://api.groupdocs.cloud/v2.0/annotation/annotations?filePath=input.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# 4. Delete all retrieved annotations
curl -X DELETE "https://api.groupdocs.cloud/v2.0/annotation/annotations?filePath=input.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d "{\"annotationIds\":[\"id1\",\"id2\"]}"

# 5. Download the cleaned PDF
curl -X GET "https://api.groupdocs.cloud/v2.0/storage/file/input.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -o output.pdf

Pour une liste complète des points de terminaison et des paramètres, consultez la documentation officielle de l’API.

Comment supprimer les objets d’annotation d’un PDF avec REST en Node.JS fonctionne

1. Configuration de l’authentification - La classe Configuration est instanciée avec votre clientId et clientSecret, créant un contexte authentifié pour tous les appels d’API ultérieurs.

   const config = new GroupDocsAnnotationCloud.Configuration(clientId, clientSecret);
   

2. Téléchargement de fichier - UploadFileRequest envoie les octets PDF locaux vers le stockage GroupDocs Cloud. La méthode storageApi.uploadFile gère le transfert.

   const uploadRequest = new GroupDocsAnnotationCloud.UploadFileRequest({
       path: remoteFilePath,
       file: fileBytes
   });
   await storageApi.uploadFile(uploadRequest);
   

3. Récupération des annotations - GetAnnotationsRequest crée un objet de requête avec une référence FileInfo. L’appel annotationsApi.getAnnotations renvoie une collection d’objets d’annotation, dont les ID sont extraits.

   const getAnnotationsRequest = new GroupDocsAnnotationCloud.GetAnnotationsRequest({
       fileInfo: fileInfo
   });
   const annotationsResult = await annotationsApi.getAnnotations(getAnnotationsRequest);
   

4. Suppression des annotations - Si des ID existent, DeleteAnnotationsRequest est rempli et transmis à annotationsApi.deleteAnnotations, qui supprime définitivement les annotations du PDF stocké.

   const deleteRequest = new GroupDocsAnnotationCloud.DeleteAnnotationsRequest({
       fileInfo: fileInfo,
       annotationIds: annotationIds
   });
   await annotationsApi.deleteAnnotations(deleteRequest);
   

5. Téléchargement du PDF nettoyé - Enfin, DownloadFileRequest récupère le fichier mis à jour, et fs.writeFileSync l’écrit sur le système de fichiers local.

   const downloadRequest = new GroupDocsAnnotationCloud.DownloadFileRequest({
       path: remoteFilePath
   });
   const fileStream = await storageApi.downloadFile(downloadRequest);
   fs.writeFileSync(localOutputPath, fileStream);
   

Pour des définitions détaillées des classes et des méthodes, consultez la référence API.

Installation et configuration GroupDocs.Annotation Cloud SDK for Node.js

Le SDK est distribué sous forme de package npm. Installez‑le avec la commande ci‑dessous, puis requérez‑le dans votre projet.

npm install groupdocs-annotation-cloud

Vous pouvez également télécharger le dernier package directement depuis la page des releases GitHub ou depuis l’URL de téléchargement officielle.

Après l’installation, importez la bibliothèque et créez un objet de configuration comme indiqué dans l’exemple de code :

const GroupDocsAnnotationCloud = require("@groupdocs/annotation-cloud");
const config = new GroupDocsAnnotationCloud.Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");

Assurez-vous que votre environnement d’exécution répond aux exigences de version de Node.js et que vous disposez d’un compte GroupDocs valide pour obtenir les informations d’identification du client.

Options et paramètres de suppression d’annotation

Le SDK expose plusieurs paramètres que vous pouvez ajuster :

• clientId / clientSecret - Identifiants pour l’authentification OAuth. Définissez‑les dans le constructeur Configuration.
• fileInfo.filePath - Le chemin du PDF dans le stockage GroupDocs Cloud. Modifiez‑le si vous stockez les fichiers dans un autre dossier.
• annotationIds - Un tableau d’ID renvoyés par GetAnnotations. Fournir un sous‑ensemble permet une suppression sélective.

Des paramètres supplémentaires tels que les délais d’attente des requêtes et la configuration du proxy sont disponibles dans la documentation du SDK ; consultez la documentation officielle pour la liste complète.

Meilleures pratiques pour la suppression des annotations PDF via REST

• Valider les ID d’annotation - Vérifiez toujours que les ID que vous prévoyez de supprimer existent ; tenter de supprimer des ID inexistants peut entraîner une erreur 404.
• Utiliser HTTPS - Toutes les appels d’API doivent être effectués via HTTPS afin de protéger vos identifiants et les données du document.
• Gérer les gros fichiers avec des téléchargements fractionnés - Pour les PDF de plus de 100 Mo, privilégiez le point de terminaison de téléchargement multipart pour éviter les dépassements de délai.
• Consigner les réponses de l’API - Enregistrez les ID de requête et les réponses pour les pistes d’audit et faciliter le dépannage.
• Réutiliser les jetons d’accès - Mettez en cache le jeton OAuth jusqu’à son expiration afin de réduire la charge d’authentification.

Questions fréquentes

• Comment m’authentifier avec GroupDocs.Annotation Cloud API ?
  Obtenez un ID client et un secret depuis votre compte GroupDocs, puis demandez un jeton d’accès via le point de terminaison OAuth. Voir la documentation officielle pour plus de détails.

• Puis-je supprimer des annotations spécifiques au lieu de toutes ?
  Oui, fournissez les ID des annotations que vous souhaitez supprimer dans le DeleteAnnotationsRequest. Le SDK renvoie la liste des ID d’annotation après un appel GetAnnotations.

• How can I remove Annotation objects from PDF with REST in Node.JS?
  Utilisez le GroupDocs.Annotation Cloud SDK for Node.js pour appeler le point de terminaison DeleteAnnotations après avoir récupéré les ID des annotations. Le flux complet est présenté dans l’exemple de code et la section cURL de ce guide.

• Quel type de licence est requis pour une utilisation en production ?
  Une licence payante est nécessaire pour la production. Vous pouvez obtenir une licence temporaire depuis la page de licence temporaire lors de l’évaluation.

Lectures complémentaires

• Extraire ou supprimer des annotations d’un PDF à l’aide de l’API REST en Node.js
• Texte barré dans un PDF avec Node.js et l’API REST
• Supprimer les annotations d’un PDF à l’aide de l’API REST en Python

Avant de commencer : prérequis et installation

Avant de commencer, assurez-vous d’avoir ce qui suit :

• Node.js 14 ou version ultérieure installé sur votre machine de développement.
• Un compte GroupDocs Cloud actif avec ID client et secret client.
• Accès aux fichiers PDF que vous souhaitez combiner, stockés dans le stockage GroupDocs Cloud.

Installez le SDK via npm et téléchargez le dernier package :

npm install groupdocs-merger-cloud

Vous pouvez également récupérer le SDK depuis la page officielle de publication : Download SDK. Après l’installation, vous êtes prêt à commencer à coder.

Guide étape par étape pour fusionner des PDF dans Node.JS

Étape 1 : Installer le SDK et importer les classes requises

Tout d’abord, importez les classes dont vous avez besoin pour fusionner des PDF.

const { MergeApi, MergeOptions, FileInfo, Configuration } = require("@groupdocs/merger-cloud");

Cette importation vous donne accès à l’API principale, aux objets de configuration et aux descripteurs de fichiers.

Étape 2 : Configurez vos informations d’identification GroupDocs

Créez un objet de configuration avec vos identifiants client.

const config = new Configuration({
    clientId: "YOUR_CLIENT_ID",
    clientSecret: "YOUR_CLIENT_SECRET"
});

Fournir les informations d’identification correctes permet à la bibliothèque d’authentifier vos requêtes.

Étape 3 : Définir les fichiers PDF à fusionner

Listez les documents PDF que vous souhaitez combiner. Cette étape vous prépare à fusionner des PDF dans Node.JS efficacement.

const filesToMerge = [
    new FileInfo({ filePath: "input1.pdf" }),
    new FileInfo({ filePath: "input2.pdf" })
];

Chaque FileInfo pointe vers un fichier stocké dans votre stockage GroupDocs Cloud.

Étape 4 : Définir les options de fusion

Configurez l’emplacement de sortie et joignez la liste des fichiers à la demande de fusion.

const mergeOptions = new MergeOptions();
mergeOptions.fileInfos = filesToMerge;
mergeOptions.outputPath = "merged_output.pdf";

Ces paramètres contrôlent la façon dont vous fusionnez des PDF dans Node.JS et où le résultat sera enregistré.

Étape 5 : Exécuter l’opération de fusion

Créez l’instance de l’API, appelez la méthode merge et gérez la réponse.

const mergeApi = new MergeApi(config);

try {
    const result = await mergeApi.mergeDocuments(mergeOptions);
    console.log("Merge completed. Output file stored at:", result.path);
} catch (error) {
    console.error("Error during PDF merge:", error);
}

L’appel asynchrone renvoie le chemin du document fusionné si l’opération réussit.

Exemple complet d’implémentation pour la fusion de PDF dans Node.JS

Le code suivant montre le flux de travail complet, de la configuration à la gestion du résultat.

const { MergeApi, MergeOptions, FileInfo, Configuration } = require("@groupdocs/merger-cloud");

// Configure the SDK (replace with your actual credentials)
const config = new Configuration({
    clientId: "YOUR_CLIENT_ID",
    clientSecret: "YOUR_CLIENT_SECRET"
});

async function mergePdfFiles() {
    // Initialize the Merge API
    const mergeApi = new MergeApi(config);

// Define the PDF files to be merged (must exist in GroupDocs Cloud storage)
    const filesToMerge = [
        new FileInfo({ filePath: "input1.pdf" }),
        new FileInfo({ filePath: "input2.pdf" })
    ];

// Set merge options
    const mergeOptions = new MergeOptions();
    mergeOptions.fileInfos = filesToMerge;
    mergeOptions.outputPath = "merged_output.pdf";

try {
        // Perform the merge operation
        const result = await mergeApi.mergeDocuments(mergeOptions);
        console.log("Merge completed. Output file stored at:", result.path);
    } catch (error) {
        console.error("Error during PDF merge:", error);
    }
}

// Execute the merge
mergePdfFiles();

Remarque : Cet exemple de code démontre la fonctionnalité principale. Avant de l’utiliser dans votre projet, assurez‑vous de mettre à jour tous les chemins de fichiers et les valeurs de configuration pour qu’ils correspondent à votre environnement réel, vérifiez que toutes les dépendances requises sont correctement installées, et testez soigneusement dans votre environnement de développement. Si vous rencontrez des problèmes, veuillez consulter la documentation officielle ou contacter l’équipe de support pour obtenir de l’aide.

Fusion de PDF via l’API REST avec cURL

Si vous préférez une approche REST pure, la même opération peut être effectuée avec des commandes cURL.

Tout d’abord, obtenez un jeton d’accès :

curl -X POST "https://api.groupdocs.cloud/v2.0/oauth2/token" \
     -H "Content-Type: application/json" \
     -d '{"client_id":"YOUR_CLIENT_ID","client_secret":"YOUR_CLIENT_SECRET","grant_type":"client_credentials"}'

Téléchargez les PDF source dans votre stockage (remplacez YOUR_ACCESS_TOKEN par le jeton de l’étape précédente):

curl -X POST "https://api.groupdocs.cloud/v2.0/storage/file/upload?path=input1.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -F "file=@/local/path/input1.pdf"

Répétez le téléchargement pour input2.pdf. Puis demandez l’opération de fusion :

curl -X POST "https://api.groupdocs.cloud/v2.0/merger/merge" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "fileInfos": [
               {"filePath":"input1.pdf"},
               {"filePath":"input2.pdf"}
           ],
           "outputPath":"merged_output.pdf"
         }'

Enfin, téléchargez le fichier fusionné :

curl -X GET "https://api.groupdocs.cloud/v2.0/storage/file/download?path=merged_output.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -o merged_output.pdf

Pour une liste complète des points de terminaison et des paramètres, consultez la référence API.

Configuration des options de fusion

Le SDK expose plusieurs options qui vous permettent d’affiner le processus de fusion :

• outputPath - Chemin de destination pour le PDF fusionné. Modifiez‑le pour contrôler l’endroit où le résultat est stocké.
• fileInfos - Un tableau d’objets FileInfo qui définissent les PDF sources et leur ordre.

Vous pouvez également définir des propriétés supplémentaires telles que pages pour fusionner des plages de pages spécifiques, ou password pour les PDF cryptés. Consultez la documentation officielle pour la liste complète des champs configurables.

Considérations de performance pour la fusion de PDF

Lors de la fusion de fichiers PDF volumineux ou nombreux, gardez ces conseils à l’esprit :

• Utilisez async/await pour éviter de bloquer la boucle d’événements, surtout pour les gros documents.
• Téléchargements par lots : téléchargez les PDF source en parallèle avant d’appeler la fusion afin de réduire la latence globale.
• Traitement en flux : pour les PDF extrêmement volumineux, envisagez de stocker les résultats intermédiaires dans le stockage cloud et de les fusionner par petits morceaux.
• PDF chiffrés : fournissez les mots de passe dans les objets FileInfo ; le traitement des fichiers chiffrés ajoute une surcharge, donc fusionnez‑les après déchiffrement lorsque cela est possible.

Appliquer ces pratiques vous aide à fusionner des PDF dans Node.JS de manière efficace tout en minimisant la consommation de mémoire.

Questions que vous pourriez avoir

• Comment fusionner des fichiers PDF dans Node.JS avec GroupDocs ?
  Utilisez le GroupDocs.Merger Cloud SDK for Node.js pour créer une instance MergeApi, configurez MergeOptions avec vos PDF source, et appelez mergeDocuments. L’exemple complet de code dans ce guide montre le processus.

• Puis-je fusionner des fichiers PDF chiffrés dans Node.JS ?
  Oui, le SDK prend en charge la fusion de PDF chiffrés. Fournissez les mots de passe corrects dans les objets FileInfo avant d’appeler mergeDocuments. Consultez la documentation officielle pour plus de détails.

• Quelles sont les options de licence pour GroupDocs.Merger ?
  GroupDocs propose des plans tarifaires flexibles. Pour les tests, vous pouvez demander une licence temporaire afin d’évaluer la bibliothèque avant d’acheter un abonnement complet.

• Où puis-je trouver plus d’exemples et de support ?
  Des échantillons supplémentaires sont disponibles sur le dépôt GitHub. Pour obtenir de l’aide, visitez le forum de support.

Lectures complémentaires

• Diviser un PDF en plusieurs PDF avec Node.JS
• Verrouiller des documents PDF avec des mots de passe en utilisant l’API REST dans Node.js
• Comment fusionner des fichiers PDF en C# en utilisant l’API REST

Ajouter un filigrane d’image aux documents PDF en Java en 5 étapes

1. Initialiser le client API : Créez une instance ApiClient avec votre ID client et votre secret.

ApiClient apiClient = new ApiClient("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
WatermarkApi watermarkApi = new WatermarkApi(apiClient);

Cette étape connecte votre code Java au service Cloud GroupDocs.Watermark. Consultez la référence API pour plus de détails.

2. Spécifiez le fichier PDF source : Créez un objet FileInfo qui pointe vers le PDF que vous souhaitez ajouter un filigrane.

FileInfo fileInfo = new FileInfo();
fileInfo.setFilePath("input.pdf");

Le fichier doit être téléchargé dans votre stockage GroupDocs avant la requête.

3. Configurer le filigrane d’image : Définissez le chemin de l’image, l’opacité, le facteur d’échelle, la rotation et l’alignement.

ImageWatermark imageWatermark = new ImageWatermark();
imageWatermark.setImagePath("watermark.png");
imageWatermark.setOpacity(0.5);
imageWatermark.setScaleFactor(0.3);
imageWatermark.setHorizontalAlignment(HorizontalAlignment.CENTER);
imageWatermark.setVerticalAlignment(VerticalAlignment.CENTER);
imageWatermark.setMargin(new Margin(10, 10, 10, 10));

Ajustez ces valeurs pour obtenir l’apparence souhaitée ; l’opacité contrôle la transparence, tandis que le facteur d’échelle détermine la taille relative à la page.

4. Définir les options de filigrane et le chemin de sortie : Combinez les informations du fichier et le filigrane dans un objet WatermarkOptions.

WatermarkOptions options = new WatermarkOptions();
options.setFileInfo(fileInfo);
options.setImageWatermark(imageWatermark);
options.setOutputPath("output.pdf");

Le outputPath indique au service où stocker le PDF résultant.

5. Exécuter la requête : Construisez un AddWatermarkRequest et appelez l’API. Gérez les réponses de succès ou d’erreur.

   AddWatermarkRequest request = new AddWatermarkRequest(options);
   try {
       AddWatermarkResponse response = watermarkApi.addWatermark(request);
       System.out.println("Watermark added successfully. Output file: " + response.getPath());
   } catch (Exception e) {
       System.err.println("Error adding watermark: " + e.getMessage());
   }
   

   Après l’exécution, le PDF filigrané est disponible à l’emplacement que vous avez spécifié.

Exemple complet de code : Ajouter un filigrane d’image aux documents PDF en Java

L’exemple suivant montre l’implémentation complète, de l’initialisation du client jusqu’à l’enregistrement du PDF filigrané.

import com.groupdocs.cloud.watermark.api.WatermarkApi;
import com.groupdocs.cloud.watermark.client.ApiClient;
import com.groupdocs.cloud.watermark.model.AddWatermarkRequest;
import com.groupdocs.cloud.watermark.model.AddWatermarkResponse;
import com.groupdocs.cloud.watermark.model.FileInfo;
import com.groupdocs.cloud.watermark.model.ImageWatermark;
import com.groupdocs.cloud.watermark.model.Margin;
import com.groupdocs.cloud.watermark.model.WatermarkOptions;
import com.groupdocs.cloud.watermark.model.enums.HorizontalAlignment;
import com.groupdocs.cloud.watermark.model.enums.VerticalAlignment;

public class AddImageWatermarkExample {
    public static void main(String[] args) {
        // Initialize API client (replace with your actual credentials)
        ApiClient apiClient = new ApiClient("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
        WatermarkApi watermarkApi = new WatermarkApi(apiClient);

// Input PDF file information
        FileInfo fileInfo = new FileInfo();
        fileInfo.setFilePath("input.pdf");

// Image watermark configuration
        ImageWatermark imageWatermark = new ImageWatermark();
        imageWatermark.setImagePath("watermark.png");          // Path to watermark image
        imageWatermark.setOpacity(0.5);                        // 50% opacity
        imageWatermark.setScaleFactor(0.3);                    // 30% of page size
        imageWatermark.setRotationAngle(0);                    // No rotation
        imageWatermark.setHorizontalAlignment(HorizontalAlignment.CENTER);
        imageWatermark.setVerticalAlignment(VerticalAlignment.CENTER);
        imageWatermark.setMargin(new Margin(10, 10, 10, 10));  // 10 points margin on all sides

// Watermark options
        WatermarkOptions options = new WatermarkOptions();
        options.setFileInfo(fileInfo);
        options.setImageWatermark(imageWatermark);
        options.setOutputPath("output.pdf"); // Resulting PDF with watermark

// Create request and call API
        AddWatermarkRequest request = new AddWatermarkRequest(options);
        try {
            AddWatermarkResponse response = watermarkApi.addWatermark(request);
            System.out.println("Watermark added successfully. Output file: " + response.getPath());
        } catch (Exception e) {
            System.err.println("Error adding watermark: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Remarque : Cet exemple de code démontre la fonctionnalité principale. Avant de l’utiliser dans votre projet, assurez‑vous de mettre à jour les chemins de fichiers (input.pdf, watermark.png, output.pdf) pour qu’ils correspondent à vos emplacements réels, vérifiez que toutes les dépendances requises sont correctement installées et testez soigneusement dans votre environnement de développement. Si vous rencontrez des problèmes, veuillez consulter la documentation officielle ou contacter l’équipe de support pour obtenir de l’aide.

Appliquer un filigrane d’image aux documents PDF via cURL et l’API REST

Voici les appels REST que vous pouvez utiliser avec cURL pour obtenir le même résultat sans écrire de code Java.

1. Obtenir un jeton d’accès

   curl -X POST "https://api.groupdocs.cloud/v2.0/auth/token" \
        -H "Content-Type: application/json" \
        -d '{"client_id":"YOUR_CLIENT_ID","client_secret":"YOUR_CLIENT_SECRET"}'
   

   La réponse contient un access_token utilisé dans les appels suivants.

2. Télécharger le PDF source

   curl -X POST "https://api.groupdocs.cloud/v2.0/storage/upload?path=input.pdf" \
        -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
        -F "file=@/path/to/input.pdf"
   

3. Téléverser l’image de filigrane

   curl -X POST "https://api.groupdocs.cloud/v2.0/storage/upload?path=watermark.png" \
        -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
        -F "file=@/path/to/watermark.png"
   

4. Ajouter le filigrane d’image

   curl -X POST "https://api.groupdocs.cloud/v2.0/watermark/add" \
        -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
        -H "Content-Type: application/json" \
        -d '{
              "fileInfo": { "filePath": "input.pdf" },
              "imageWatermark": {
                  "imagePath": "watermark.png",
                  "opacity": 0.5,
                  "scaleFactor": 0.3,
                  "horizontalAlignment": "Center",
                  "verticalAlignment": "Center",
                  "margin": { "top": 10, "right": 10, "bottom": 10, "left": 10 }
              },
              "outputPath": "output.pdf"
            }'
   

   Cette requête reproduit la logique du code Java, en appliquant les mêmes paramètres d’opacité, d’échelle et d’alignement.

5. Télécharger le PDF filigrané

   curl -X GET "https://api.groupdocs.cloud/v2.0/storage/download?path=output.pdf" \
        -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
        -o output.pdf
   

Pour plus de détails sur les corps de requête et les paramètres pris en charge, consultez la documentation officielle de l’API.

Installation et configuration du GroupDocs.Watermark Cloud SDK for Java

Ajoutez la dépendance Maven à votre pom.xml (ou le fragment Gradle équivalent). La bibliothèque est hébergée sur Maven Central.

<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-watermark-cloud</artifactId>
    <version>23.8</version>
</dependency>

Vous avez également besoin d’un compte GroupDocs Cloud valide. Récupérez votre Client ID et Client Secret depuis le portail GroupDocs. Aucune installation d’exécution supplémentaire n’est requise car le SDK communique avec le service cloud.

Affinement des options de filigrane d’image pour les documents PDF

Le SDK expose plusieurs propriétés qui vous permettent de contrôler l’apparence visuelle du filigrane.

Ajuster l’opacité

imageWatermark.setOpacity(0.75); // 75% opacity for a more visible watermark

Les valeurs d’opacité vont de 0.0 (totalement transparent) à 1.0 (totalement opaque).

Modifier le facteur d’échelle

imageWatermark.setScaleFactor(0.5); // Watermark occupies 50% of the page width

Le facteur d’échelle détermine la taille du filigrane par rapport aux dimensions de la page.

Définir l’alignement et les marges

imageWatermark.setHorizontalAlignment(HorizontalAlignment.RIGHT);
imageWatermark.setVerticalAlignment(VerticalAlignment.BOTTOM);
imageWatermark.setMargin(new Margin(20, 20, 20, 20));

Ces paramètres placent le filigrane dans le coin inférieur‑droit avec une marge de 20 points.

Pour une liste complète des propriétés configurables, consultez la référence API.

Conclusion

Ajouter un filigrane d’image aux documents PDF en Java est une tâche simple lorsque vous utilisez le GroupDocs.Watermark Cloud SDK for Java. Le SDK gère toute la manipulation PDF de bas niveau, vous permettant de vous concentrer sur les aspects visuels tels que l’opacité, le redimensionnement et le positionnement. Que vous préfériez une implémentation Java native ou un flux de travail cURL basé sur le cloud, les mêmes résultats de haute qualité sont réalisables sans sacrifier les performances. N’oubliez pas d’obtenir une licence appropriée pour une utilisation en production ; les détails de tarification sont disponibles sur la page du produit et une page de licence temporaire peut être utilisée pour l’évaluation.

FAQs

• Comment ajouter un filigrane d’image à un PDF en Java sans perdre la qualité ?
  Utilisez la propriété scaleFactor pour dimensionner le filigrane par rapport à la page et conserver le DPI d’origine du PDF source. Le SDK préserve la résolution du PDF, de sorte que le filigrane reste net à n’importe quel niveau de zoom.

• Puis-je ajouter plusieurs filigranes au même PDF ?
  Oui. Créez des objets ImageWatermark distincts avec des configurations différentes et ajoutez‑les séquentiellement en appelant addWatermark plusieurs fois ou en les ajoutant à une liste dans la requête.

• Quels sont les formats d’image pris en charge pour le filigrane ?
  L’API accepte les types d’image courants tels que PNG, JPG, BMP, GIF et TIFF. PNG est recommandé pour une qualité sans perte et la prise en charge de la transparence.

• Existe-t-il un moyen de prévisualiser le filigrane avant de l’appliquer ?
  Vous pouvez utiliser le GroupDocs.Watermark Cloud SDK for Java pour générer un PDF temporaire avec le filigrane et le télécharger pour révision. Cela utilise le même appel addWatermark avec un chemin de sortie pointant vers un emplacement temporaire.

Read More

• Ajouter un filigrane aux images avec Java
• Ajouter un filigrane à Word en Java - Créateur de filigrane
• Ajouter un filigrane d’image à PDF | Comment ajouter un filigrane aux documents PDF avec .NET