Vollständiges funktionierendes Beispiel zum Entfernen von Annotationsobjekten aus PDF mit REST in Node.JS

Dieses Beispiel zeigt, wie man ein PDF hochlädt, alle seine Anmerkungen löscht und die bereinigte Datei mit dem GroupDocs.Annotation SDK herunterlädt.

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

Hinweis: Dieses Codebeispiel demonstriert die Kernfunktionalität. Bevor Sie es in Ihrem Projekt verwenden, stellen Sie sicher, dass Sie alle Dateipfade und Konfigurationswerte an Ihre tatsächliche Umgebung anpassen, überprüfen Sie, dass alle erforderlichen Abhängigkeiten ordnungsgemäß installiert sind, und testen Sie gründlich in Ihrer Entwicklungsumgebung. Wenn Sie auf Probleme stoßen, konsultieren Sie bitte die offizielle Dokumentation oder wenden Sie sich an das Support-Team für Unterstützung.

PDF-Anmerkungen über die REST-API mit cURL löschen

Im Folgenden finden Sie die cURL‑Befehle, die denselben Workflow zum Entfernen von Anmerkungen über die GroupDocs.Annotation Cloud REST‑Endpunkte ausführen.

# 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

Für eine vollständige Liste der Endpunkte und Parameter siehe die offizielle API-Dokumentation.

Wie das Entfernen von Annotationsobjekten aus PDF mit REST in Node.JS funktioniert

1. Authentifizierung einrichten – Die Configuration‑Klasse wird mit Ihrem clientId und clientSecret instanziiert und erstellt einen authentifizierten Kontext für alle nachfolgenden API‑Aufrufe.

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

2. Datei‑Upload – UploadFileRequest sendet die lokalen PDF‑Bytes an den GroupDocs Cloud‑Speicher. Die Methode storageApi.uploadFile übernimmt die Übertragung.

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

3. Annotationen abrufen – GetAnnotationsRequest erstellt ein Anforderungsobjekt mit einem FileInfo‑Verweis. Der Aufruf annotationsApi.getAnnotations gibt eine Sammlung von Annotationsobjekten zurück, aus denen die IDs extrahiert werden.

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

4. Annotationen löschen – Wenn IDs vorhanden sind, wird DeleteAnnotationsRequest gefüllt und an annotationsApi.deleteAnnotations übergeben, das die Annotationen dauerhaft aus dem gespeicherten PDF entfernt.

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

5. Bereinigtes PDF herunterladen – Schließlich ruft DownloadFileRequest die aktualisierte Datei ab und fs.writeFileSync schreibt sie in das lokale Dateisystem.

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

Für detaillierte Klassen‑ und Methodendefinitionen siehe die API‑Referenz.

Installation und Konfiguration GroupDocs.Annotation Cloud SDK for Node.js

Das SDK wird als npm‑Paket bereitgestellt. Installieren Sie es mit dem untenstehenden Befehl und binden Sie es dann in Ihrem Projekt ein.

npm install groupdocs-annotation-cloud

Sie können das neueste Paket auch direkt von der GitHub‑Release‑Seite oder der offiziellen Download‑URL herunterladen.

Nach der Installation importieren Sie die Bibliothek und erstellen ein Konfigurationsobjekt, wie im Codebeispiel gezeigt:

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

Stellen Sie sicher, dass Ihre Laufzeitumgebung die Node.js-Versionanforderungen erfüllt und dass Sie ein gültiges GroupDocs‑Konto besitzen, um die Client‑Anmeldeinformationen zu erhalten.

Optionen und Einstellungen zum Entfernen von Anmerkungen

Das SDK stellt mehrere Parameter zur Verfügung, die Sie anpassen können:

• clientId / clientSecret - Anmeldeinformationen für die OAuth-Authentifizierung. Legen Sie sie im Configuration-Konstruktor fest.
• fileInfo.filePath - Der Pfad der PDF-Datei im GroupDocs Cloud-Speicher. Passen Sie ihn an, wenn Sie Dateien in einem anderen Ordner speichern.
• annotationIds - Ein Array von IDs, das von GetAnnotations zurückgegeben wird. Die Angabe eines Teilsets ermöglicht eine selektive Löschung.

Zusätzliche Einstellungen wie Anforderungs‑Timeouts und Proxy‑Konfiguration sind in der SDK‑Dokumentation verfügbar; siehe die offizielle Dokumentation für die vollständige Liste.

Best Practices für das Entfernen von PDF-Anmerkungen über REST

• Annotation IDs validieren - Stellen Sie stets sicher, dass die IDs, die Sie löschen möchten, existieren; der Versuch, nicht vorhandene IDs zu löschen, kann einen 404‑Fehler verursachen.
• HTTPS verwenden - Alle API-Aufrufe müssen über HTTPS erfolgen, um Ihre Anmeldeinformationen und Dokumentdaten zu schützen.
• Große Dateien mit Chunked Uploads verarbeiten - Bei PDFs, die größer als 100 MB sind, sollten Sie den Multipart‑Upload‑Endpunkt bevorzugen, um Zeitüberschreitungen zu vermeiden.
• API‑Antworten protokollieren - Speichern Sie Anforderungs‑IDs und Antworten für Prüfpfade und einfachere Fehlersuche.
• Access‑Tokens wiederverwenden - Zwischenspeichern Sie das OAuth‑Token, bis es abläuft, um den Authentifizierungsaufwand zu reduzieren.

Häufige Fragen

• Wie authentifiziere ich mich bei der GroupDocs.Annotation Cloud API?
  Holen Sie eine Client-ID und ein Geheimnis aus Ihrem GroupDocs-Konto und fordern Sie dann ein Zugriffstoken über den OAuth-Endpunkt an. Siehe die offizielle Dokumentation für Details.

• Kann ich bestimmte Anmerkungen statt aller löschen?
  Ja, geben Sie die IDs der Anmerkungen an, die Sie entfernen möchten, im DeleteAnnotationsRequest. Das SDK gibt die Liste der Anmerkungs‑IDs nach einem GetAnnotations‑Aufruf zurück.

• Wie kann ich Annotationsobjekte aus einem PDF mit REST in Node.JS entfernen?
  Verwenden Sie das GroupDocs.Annotation Cloud SDK für Node.js, um den DeleteAnnotations-Endpunkt aufzurufen, nachdem Sie die Annotations-IDs abgerufen haben. Der vollständige Arbeitsablauf wird im Codebeispiel und im cURL-Abschnitt dieses Leitfadens demonstriert.

• Welche Lizenz ist für die Produktion erforderlich?
  Für die Produktion ist eine kostenpflichtige Lizenz erforderlich. Sie können während der Evaluierung eine temporäre Lizenz von der temporäre Lizenzseite erwerben.

Weiterführende Lektüre

• Extrahieren oder Entfernen von Anmerkungen aus PDF mit REST-API in Node.js
• Durchgestrichener Text in einem PDF mit Node.js und REST-API
• Entfernen von Anmerkungen aus PDF mit REST-API in Python

Bevor Sie beginnen: Voraussetzungen und Installation

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• Node.js 14 oder neuer, installiert auf Ihrem Entwicklungsrechner.
• Ein aktives GroupDocs Cloud‑Konto mit Client‑ID und Client‑Secret.
• Zugriff auf die PDF‑Dateien, die Sie kombinieren möchten, gespeichert im GroupDocs Cloud‑Speicher.

Installieren Sie das SDK über npm und laden Sie das neueste Paket herunter:

npm install groupdocs-merger-cloud

Sie können das SDK auch von der offiziellen Release‑Seite abrufen: Download SDK. Nach der Installation sind Sie bereit, mit dem Codieren zu beginnen.

Schritt-für-Schritt-Anleitung zum Zusammenführen von PDF in Node.JS

Schritt 1: SDK installieren und erforderliche Klassen importieren

Zuerst importieren Sie die Klassen, die Sie zum Zusammenführen von PDFs benötigen.

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

Dieser Import gibt Ihnen Zugriff auf die Kern‑API, Konfigurationsobjekte und Dateideskriptoren.

Schritt 2: Konfigurieren Sie Ihre GroupDocs Credentials

Erstellen Sie ein Konfigurationsobjekt mit Ihren Client‑Anmeldeinformationen.

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

Das Bereitstellen der richtigen Anmeldeinformationen ermöglicht es der Bibliothek, Ihre Anfragen zu authentifizieren.

Schritt 3: Definieren Sie die PDF-Dateien, die zusammengeführt werden sollen

Listen Sie die PDF‑Dokumente auf, die Sie kombinieren möchten. Dieser Schritt bereitet Sie darauf vor, PDF in Node.JS effizient zusammenzuführen.

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

Jede FileInfo verweist auf eine Datei, die in Ihrem GroupDocs Cloud‑Speicher gespeichert ist.

Schritt 4: Merge-Optionen festlegen

Konfigurieren Sie den Ausgabespeicherort und fügen Sie die Dateiliste dem Merge‑Request bei.

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

Diese Einstellungen steuern, wie Sie PDF in Node.JS zusammenführen und wo das Ergebnis gespeichert wird.

Schritt 5: Ausführen der Merge-Operation

Erstellen Sie die API‑Instanz, rufen Sie die Merge‑Methode auf und verarbeiten Sie die Antwort.

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

Der asynchrone Aufruf gibt den Pfad des zusammengeführten Dokuments zurück, wenn die Operation erfolgreich ist.

Vollständiges Implementierungsbeispiel für das Zusammenführen von PDFs in Node.JS

Der folgende Code demonstriert den vollständigen Workflow von der Konfiguration bis zur Ergebnisverarbeitung.

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

Hinweis: Dieses Codebeispiel demonstriert die Kernfunktionalität. Bevor Sie es in Ihrem Projekt verwenden, stellen Sie sicher, dass Sie alle Dateipfade und Konfigurationswerte an Ihre tatsächliche Umgebung anpassen, überprüfen Sie, dass alle erforderlichen Abhängigkeiten ordnungsgemäß installiert sind, und testen Sie gründlich in Ihrer Entwicklungsumgebung. Wenn Sie auf Probleme stoßen, lesen Sie bitte die offizielle Dokumentation oder wenden Sie sich an das Support-Team für Unterstützung.

Zusammenführen von PDFs über die REST-API mit cURL

Wenn Sie einen reinen REST‑Ansatz bevorzugen, kann dieselbe Operation mit cURL‑Befehlen ausgeführt werden.

Zuerst ein Zugriffstoken erhalten:

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

Laden Sie die Quell‑PDFs in Ihren Speicher hoch (ersetzen Sie YOUR_ACCESS_TOKEN durch das Token aus dem vorherigen Schritt):

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"

Wiederholen Sie den Upload für input2.pdf. Anschließend fordern Sie die Merge‑Operation an:

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

Laden Sie schließlich die zusammengeführte Datei herunter:

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

Für eine vollständige Liste der Endpunkte und Parameter siehe die API‑Referenz.

Merge-Optionen konfigurieren

Das SDK bietet mehrere Optionen, mit denen Sie den Zusammenführungsprozess feinabstimmen können:

• outputPath – Zielpfad für das zusammengeführte PDF. Passen Sie dies an, um zu steuern, wo das Ergebnis gespeichert wird.
• fileInfos – Ein Array von FileInfo‑Objekten, das die Quell‑PDFs und deren Reihenfolge definiert.

Sie können auch zusätzliche Eigenschaften wie pages festlegen, um bestimmte Seitenbereiche zusammenzuführen, oder password für verschlüsselte PDFs. Weitere Informationen finden Sie in der offiziellen Dokumentation für die vollständige Liste der konfigurierbaren Felder.

Leistungsüberlegungen beim Zusammenführen von PDFs

Beim Zusammenführen großer oder vieler PDF-Dateien sollten Sie diese Tipps beachten:

• Verwenden Sie async/await um die Event‑Schleife nicht zu blockieren, insbesondere bei großen Dokumenten.
• Batch‑Uploads: Laden Sie Quell‑PDFs parallel hoch, bevor Sie den Merge aufrufen, um die Gesamtlatenz zu reduzieren.
• Stream‑Verarbeitung: Für extrem große PDFs sollten Sie erwägen, Zwischenergebnisse im Cloud‑Speicher zu speichern und sie in kleineren Teilen zusammenzuführen.
• Verschlüsselte PDFs: Geben Sie Passwörter in den FileInfo‑Objekten an; die Verarbeitung verschlüsselter Dateien verursacht zusätzlichen Aufwand, daher sollten Sie sie nach Möglichkeit nach der Entschlüsselung zusammenführen.

Durch die Anwendung dieser Praktiken können Sie PDF in Node.JS effizient zusammenführen und gleichzeitig den Speicherverbrauch minimieren.

Fragen, die Sie haben könnten

• Wie kann ich PDF-Dateien in Node.JS mit GroupDocs zusammenführen?
  Verwenden Sie das GroupDocs.Merger Cloud SDK for Node.js, um eine MergeApi-Instanz zu erstellen, MergeOptions mit Ihren Quell‑PDFs zu konfigurieren und mergeDocuments aufzurufen. Das vollständige Codebeispiel in diesem Leitfaden demonstriert den Vorgang.

• Kann ich verschlüsselte PDF-Dateien in Node.JS zusammenführen?
  Ja, das SDK unterstützt das Zusammenführen verschlüsselter PDFs. Geben Sie die richtigen Passwörter in den FileInfo‑Objekten an, bevor Sie mergeDocuments aufrufen. Siehe die offizielle Dokumentation für Details.

• Was sind die Lizenzoptionen für GroupDocs.Merger?
  GroupDocs bietet flexible Preispläne. Zum Testen können Sie eine temporäre Lizenz anfordern, um die Bibliothek vor dem Kauf eines Vollabonnements zu evaluieren.

• Wo finde ich weitere Beispiele und Support?
  Zusätzliche Beispiele sind im GitHub-Repository verfügbar. Für Hilfe besuchen Sie das Support-Forum.

Weiterführende Lektüre

• PDF in mehrere PDFs aufteilen in Node.JS
• PDF-Dokumente mit Passwörtern mittels REST API in Node.js sperren
• PDF-Dateien in C# mit REST API zusammenführen

Bildwasserzeichen zu PDF-Dokumenten in Java in 5 Schritten hinzufügen

1. Initialisieren des API-Clients: Erstellen Sie eine ApiClient‑Instanz mit Ihrer Client‑ID und Ihrem Geheimschlüssel.

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

Dieser Schritt verbindet Ihren Java‑Code mit dem GroupDocs.Watermark Cloud‑Dienst. Siehe die API‑Referenz für weitere Details.

2. Geben Sie die Quell-PDF-Datei an: Erstellen Sie ein FileInfo-Objekt, das auf die PDF verweist, die Sie mit einem Wasserzeichen versehen möchten.

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

   Die Datei muss vor der Anforderung in Ihren GroupDocs-Speicher hochgeladen werden.

3. Bildwasserzeichen konfigurieren: Definieren Sie den Bildpfad, die Deckkraft, den Skalierungsfaktor, die Drehung und die Ausrichtung.

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

   Passen Sie diese Werte an, um das gewünschte Aussehen zu erzielen; die Deckkraft steuert die Transparenz, während der Skalierungsfaktor die Größe relativ zur Seite bestimmt.

4. Wasserzeichen-Optionen und Ausgabepfad festlegen: Kombinieren Sie die Dateiinformationen und das Wasserzeichen in einem WatermarkOptions-Objekt.

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

Der outputPath gibt dem Dienst an, wo das resultierende PDF gespeichert werden soll.

5. Führen Sie die Anforderung aus: Erstellen Sie ein AddWatermarkRequest und rufen Sie die API auf. Behandeln Sie Erfolgs‑ oder Fehlermeldungen.

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

   Nach der Ausführung ist das mit Wasserzeichen versehene PDF an dem von Ihnen angegebenen Ort verfügbar.

Vollständiges Codebeispiel: Bildwasserzeichen zu PDF-Dokumenten in Java hinzufügen

Das folgende Beispiel zeigt die vollständige Implementierung von der Client‑Initialisierung bis zum Speichern des mit Wasserzeichen versehenen PDFs.

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

Hinweis: Dieses Codebeispiel demonstriert die Kernfunktionalität. Bevor Sie es in Ihrem Projekt verwenden, stellen Sie sicher, dass Sie die Dateipfade (input.pdf, watermark.png, output.pdf) an Ihre tatsächlichen Speicherorte anpassen, überprüfen Sie, dass alle erforderlichen Abhängigkeiten korrekt installiert sind, und testen Sie gründlich in Ihrer Entwicklungsumgebung. Wenn Sie auf Probleme stoßen, lesen Sie bitte die offizielle Dokumentation oder wenden Sie sich an das Support-Team für Unterstützung.

Bildwasserzeichen auf PDF-Dokumente anwenden über cURL und REST API

Im Folgenden finden Sie die REST‑Aufrufe, die Sie mit cURL verwenden können, um dasselbe Ergebnis zu erzielen, ohne Java‑Code zu schreiben.

1. Zugriffstoken erhalten

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

   Die Antwort enthält ein access_token, das in nachfolgenden Aufrufen verwendet wird.

2. Laden Sie die Quell-PDF hoch

   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. Wasserzeichen‑Bild hochladen

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. Bildwasserzeichen hinzufügen

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

Diese Anfrage spiegelt die Logik des Java-Codes wider und wendet dieselben Einstellungen für Deckkraft, Skalierung und Ausrichtung an.

5. Herunterladen des mit Wasserzeichen versehenen PDFs

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

Für weitere Details zu Anforderungskörpern und unterstützten Parametern siehe die offizielle API-Dokumentation.

Installation und Konfiguration des GroupDocs.Watermark Cloud SDK für Java

Fügen Sie die Maven‑Abhängigkeit zu Ihrer pom.xml hinzu (oder das entsprechende Gradle‑Snippet). Die Bibliothek wird im Maven Central gehostet.

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

Sie benötigen außerdem ein gültiges GroupDocs Cloud‑Konto. Rufen Sie Ihre Client ID und Client Secret aus dem GroupDocs portal ab. Es ist keine zusätzliche Laufzeitinstallation erforderlich, da das SDK mit dem Cloud‑Dienst kommuniziert.

Feinabstimmung der Bildwasserzeichen-Optionen für PDF-Dokumente

Das SDK stellt mehrere Eigenschaften bereit, mit denen Sie das visuelle Erscheinungsbild des Wasserzeichens steuern können.

Deckkraft anpassen

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

Deckkraftwerte reichen von 0.0 (vollständig transparent) bis 1.0 (vollständig undurchsichtig).

Skalierungsfaktor ändern

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

Der Skalierungsfaktor bestimmt die Größe des Wasserzeichens relativ zu den Seitenabmessungen.

Ausrichtung und Ränder festlegen

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

Diese Einstellungen platzieren das Wasserzeichen in der unteren rechten Ecke mit einem Abstand von 20 Punkten.

Für eine vollständige Liste der konfigurierbaren Eigenschaften, siehe die API-Referenz.

Fazit

Das Hinzufügen eines Bildwasserzeichens zu PDF‑Dokumenten in Java ist eine unkomplizierte Aufgabe, wenn Sie das GroupDocs.Watermark Cloud SDK for Java verwenden. Das SDK übernimmt die gesamte Low‑Level‑PDF‑Manipulation, sodass Sie sich auf die visuellen Aspekte wie Transparenz, Skalierung und Positionierung konzentrieren können. Egal, ob Sie eine native Java‑Implementierung oder einen cloud‑basierten cURL‑Workflow bevorzugen, dieselben hochwertigen Ergebnisse sind ohne Leistungseinbußen erreichbar. Denken Sie daran, für den Produktionseinsatz eine gültige Lizenz zu erwerben; Preisdetails finden Sie auf der Produktseite und eine temporäre Lizenzseite kann für die Evaluierung verwendet werden.

FAQs

• Wie füge ich einem PDF in Java ein Bildwasserzeichen hinzu, ohne die Qualität zu verlieren?
  Verwenden Sie die scaleFactor‑Eigenschaft, um das Wasserzeichen relativ zur Seite zu skalieren und die ursprüngliche DPI des Quell‑PDFs beizubehalten. Das SDK bewahrt die Auflösung des PDFs, sodass das Wasserzeichen bei jedem Zoom‑Level scharf erscheint.

• Kann ich mehrere Wasserzeichen zum selben PDF hinzufügen?
  Ja. Erstellen Sie separate ImageWatermark-Objekte mit unterschiedlichen Konfigurationen und fügen Sie sie nacheinander hinzu, indem Sie addWatermark mehrmals aufrufen oder sie zu einer Liste in der Anfrage hinzufügen.

• Welche Bildformate werden für das Wasserzeichen unterstützt?
  Die API akzeptiert gängige Bildtypen wie PNG, JPG, BMP, GIF und TIFF. PNG wird für verlustfreie Qualität und Transparenzunterstützung empfohlen.

• Gibt es eine Möglichkeit, das Wasserzeichen vor dem Anwenden in der Vorschau zu sehen?
  Sie können das GroupDocs.Watermark Cloud SDK für Java verwenden, um ein temporäres PDF mit dem Wasserzeichen zu erzeugen und es zur Überprüfung herunterzuladen. Dabei wird derselbe addWatermark-Aufruf mit einem Ausgabepfad verwendet, der auf einen temporären Speicherort verweist.

Mehr lesen

• Wasserzeichen zu Bildern hinzufügen mit Java
• Wasserzeichen zu Word in Java hinzufügen – Watermark Creator
• Bildwasserzeichen zu PDF hinzufügen | So fügen Sie PDF-Dokumenten ein Wasserzeichen mit .NET hinzu