Java Handtekeningverificatie – Digitale Handtekeningen Verifiëren in Java

Introductie

Heb je ooit een digitaal ondertekend document ontvangen en je afgevraagd, “Is dit echt van wie het beweert te zijn?” Je bent niet de enige. Met digitale fraude die toeneemt, is java signature verification cruciaal geworden voor elke applicatie die gevoelige documenten verwerkt—of je nu een contractbeheersysteem bouwt, financiële overeenkomsten verwerkt, of overheidsdocumenten valideert.

Hier is de uitdaging: de ingebouwde handtekeningverificatie van Java kan complex en beperkt zijn. Daar komt GroupDocs.Signature for Java om de hoek kijken. Het vereenvoudigt het hele proces en biedt krachtige opties zoals datumgebaseerde verificatie en aangepaste validatieregels.

In deze gids leer je precies hoe je:

  • Installeer en configureer GroupDocs.Signature in je Java‑project
  • Verifieer digitale handtekeningen met aangepaste opties en parameters
  • Voer datum‑specifieke verificatie uit voor tijdgevoelige documenten
  • Vermijd veelvoorkomende valkuilen die de beveiliging kunnen ondermijnen
  • Implementeer productie‑klare handtekeningvalidatie

Laten we beginnen met wat je nodig hebt om aan de slag te gaan.

Snelle Antwoorden

  • Wat is de gemakkelijkste manier om een PDF-handtekening te verifiëren in Java? Gebruik Signature.verify() met een VerificationOptions‑object van GroupDocs.Signature.
  • Heb ik een licentie nodig voor productie? Ja—GroupDocs.Signature vereist een commerciële of tijdelijke licentie voor productiegebruik.
  • Kan ik handtekeningen verifiëren die ouder zijn dan de vervaldatum van het certificaat? Ja—stel een verificatiedatum in met VerificationOptions.setVerificationTime().
  • Hoeveel documentformaten worden ondersteund? Meer dan 30 formaten, inclusief PDF, DOCX, XLSX, PPTX en PNG.
  • Welke Java‑versie wordt aanbevolen? Java 11+ voor de beste beveiliging en prestaties.

Wat is Java handtekeningverificatie?

java signature verification is het proces waarbij programmatisch wordt bevestigd dat een digitale handtekening die in een document is ingebed authentiek, onaangetast en gemaakt door een vertrouwde ondertekenaar is. Het omvat cryptografische controles, validatie van de certificaatketen en optionele tijd‑gebaseerde validatie. Deze verificatiestap waarborgt de identiteit van de ondertekenaar en garandeert dat het document niet is gewijzigd sinds ondertekening.

Waarom Digitale Handtekeningverificatie Belangrijk Is

Voordat we in de code duiken, laten we bespreken waarom dit belangrijk is. Digitale handtekeningen doen drie cruciale dingen: ze bevestigen authenticiteit, garanderen integriteit en bieden non‑repudiatie. In praktische termen betekent dit dat je kunt vertrouwen dat een factuur echt van je leverancier komt, dat een contract niet is gemanipuleerd, en dat een ondertekende overeenkomst juridisch standhoudt. Sectoren zoals gezondheidszorg (HIPAA‑naleving), financiën (SOX‑vereisten) en overheidscontracten zijn hier elke dag op aangewezen.

Vereisten

Voordat we beginnen, zorg dat je het volgende hebt:

  • Java Development Kit (JDK): Versie 8 of hoger (Java 11+ aanbevolen voor betere beveiligingsfuncties)
  • IDE: IntelliJ IDEA, Eclipse, of VS Code met Java‑extensies
  • Build‑tool: Maven of Gradle voor afhankelijkheidsbeheer
  • Basiskennis van Java: Begrip van klassen, objecten en bestands‑I/O

Je hoeft geen cryptografie‑expert te zijn (gelukkig!), maar een basiskennis van digitale handtekeningen helpt. Als je nieuw bent met het concept, zie het dan als een waszegel op een envelop—het bewijst wie het heeft verzonden en of iemand het heeft geopend.

GroupDocs.Signature voor Java Instellen

Laten we GroupDocs.Signature integreren in je project. De installatie is eenvoudig, ongeacht of je Maven of Gradle gebruikt.

Maven‑configuratie

Voeg deze afhankelijkheid toe aan je pom.xml‑bestand:

<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-signature</artifactId>
    <version>23.12</version>
</dependency>

Gradle‑configuratie

Voor Gradle‑gebruikers, voeg dit toe aan je build.gradle‑bestand:

implementation 'com.groupdocs:groupdocs-signature:23.12'

Pro Tip: Controleer altijd de GroupDocs releases page voor de nieuwste versie. Nieuwere versies bevatten vaak beveiligingspatches en prestatieverbeteringen.

Je Licentie Verkrijgen

GroupDocs.Signature heeft een licentie nodig voor productiegebruik. Hier zijn je opties:

  1. Gratis proefversie: Ideaal voor testen en ontwikkeling (Download hier)
  2. Tijdelijke licentie: Volledige functionaliteit voor 30 dagen (Vraag hier aan)
  3. Commerciële licentie: Voor productie‑implementaties (Koop hier)

De gratis proefversie heeft enkele beperkingen (zoals watermerken), maar is perfect voor leren en prototypen.

Basisinitialisatie

Zodra je de afhankelijkheid hebt geregeld, kun je de bibliotheek als volgt initialiseren:

De Signature‑klasse is het primaire toegangspunt dat een document laadt en ondertekenings‑ en verificatiemethoden biedt.

import com.groupdocs.signature.Signature;

String filePath = "YOUR_DOCUMENT_DIRECTORY/sample_signed_document.pdf";
Signature signature = new Signature(filePath);

Digitale Handtekeningen Verifiëren: De Basis

Nu het leuke gedeelte. Laten we stap voor stap een digitaal ondertekend document verifiëren.

Wat is de eerste stap in java signature verification?

Laad het document met een Signature‑instantie en roep verify() aan met een correct geconfigureerd VerificationOptions‑object. Deze enkele oproep voert cryptografische validatie, integriteitscontroles en certificaatketen‑validatie uit. Het waarborgt de authenticiteit van het document en dat het certificaat van de ondertekenaar op het moment van verificatie wordt vertrouwd.

Stap 1: Vereiste Pakketten Importeren

De volgende imports brengen de kernklassen binnen die nodig zijn voor het laden van documenten, het configureren van verificatie en het verwerken van resultaten.

import com.groupdocs.signature.Signature;
import com.groupdocs.signature.domain.VerificationResult;
import com.groupdocs.signature.options.verify.DigitalVerifyOptions;

Stap 2: Verificatie‑opties Configureren

Hier wordt het interessant. Je kunt het verificatieproces aanpassen met specifieke parameters. Voeg bijvoorbeeld een opmerking toe om bij te houden waarom we dit document verifiëren:

VerificationOptions definieert de criteria en instellingen die tijdens het verificatieproces worden gebruikt, zoals welke handtekeningen moeten worden gecontroleerd en eventuele aangepaste validatieregels.

DigitalVerifyOptions options = new DigitalVerifyOptions();
options.setComments("Approved");  // Tracks verification context

Waarom opmerkingen toevoegen? Ze zijn enorm nuttig voor audit‑trails. Wanneer je zes maanden later de logs bekijkt, weet je precies waarom een document is geverifieerd en op basis van welke criteria.

Stap 3: Voer de Verificatie Uit

Voer nu de verificatie uit:

VerificationResult bevat het resultaat van de verificatie‑operatie, geeft succes of falen aan en biedt gedetailleerde informatie over eventuele problemen.

VerificationResult result = signature.verify(options);
if (result.isValid()) {
    System.out.println("The document was verified successfully.");
} else {
    System.out.println("The document failed the verification process.");
}

VerificationResult is een beknopt object dat aangeeft of de handtekening alle controles heeft doorstaan en geeft gedetailleerde foutredenen wanneer dit niet het geval is. De bibliotheek controleert:

  • Is de handtekening cryptografisch geldig?
  • Is het document gewijzigd sinds ondertekening?
  • Valideert de certificaatketen correct?

Als alle controles slagen, krijg je true. Als er een controle faalt, krijg je false—en moet je dat document als verdacht behandelen.

Datum‑Specifieke Verificatie Afhandelen

Soms moet je verifiëren of een handtekening op een specifiek moment geldig was. Dit is cruciaal voor juridische documenten waarbij je moet bewijzen “dit was geldig op 15 oktober 2024, zelfs als het certificaat later is verlopen.”

Waarom Datumafhandeling Belangrijk Is

Stel je dit scenario voor: een contract werd op 1 juni ondertekend met een certificaat dat op 1 juli verloopt. Je verifieert het op 1 augustus. Zonder datumafhandeling faalt de verificatie omdat het certificaat verlopen is. Met datum‑gebaseerde verificatie kun je bevestigen dat het destijds geldig was—wat juridisch van belang is.

Een Verificatiedatum Instellen

VerificationOptions.setVerificationTime() maakt het mogelijk om het exacte moment in de tijd op te geven waarop de geldigheid van het certificaat moet worden geëvalueerd.

import java.util.Date;
import java.text.SimpleDateFormat;

// Verify as if it's a specific date
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date verificationDate = dateFormat.parse("2024-06-15");

options.setVerificationDate(verificationDate);

Datum‑Gebaseerde Verificatie Uitvoeren

Voer nu de verificatie uit met je datumparameter:

De verify()‑aanroep gebruikt de eerder ingestelde verificatietijd om de handtekening te beoordelen alsof deze op dat historische moment wordt gecontroleerd.

VerificationResult result = signature.verify(options);
if (result.isValid()) {
    System.out.println("The document was verified successfully for the specified date.");
} else {
    System.out.println("The document failed verification for that date.");
}

Real‑world use case: Financiële instellingen gebruiken dit bij het auditen van historische transacties. Ze moeten bevestigen dat handtekeningen geldig waren op het moment van ondertekening, niet alleen nu.

Veelvoorkomende Fouten bij het Verifiëren van Handtekeningen

Laat me je wat hoofdpijn besparen. Hier zijn fouten die ik bij ontwikkelaars heb gezien (en zelf heb gemaakt tijdens het leren):

1. Het Vergeten Controleren van de Geldigheidsperiode van Certificaten

The Mistake: Aannemen dat een handtekening ongeldig is alleen omdat het certificaat is verlopen.
The Fix: Gebruik altijd datum‑gebaseerde verificatie voor historische documenten. Controleer wanneer het document is ondertekend, niet alleen of het certificaat vandaag geldig is.

2. Geen Omgaan met Bestands‑pad Problemen

The Mistake: Hard‑coded bestands‑paden die breken in verschillende omgevingen.
The Fix:

Gebruik Paths.get() om platform‑onafhankelijke paden te bouwen en hard‑coded scheidingstekens te vermijden.

// Don't do this:
String filePath = "C:\\Users\\John\\Documents\\contract.pdf";

// Do this instead:
String filePath = System.getProperty("user.dir") + "/documents/contract.pdf";
// Or use proper configuration files

3. Het Negeren van Details van het Verificatieresultaat

The Mistake: Alleen isValid() controleren zonder te onderzoeken waarom verificatie is mislukt.
The Fix:

Log result.getErrorMessage() en result.getErrorCode() om gedetailleerde foutredenen te krijgen.

VerificationResult result = signature.verify(options);
if (!result.isValid()) {
    // Get detailed failure information
    System.out.println("Verification failed. Details:");
    result.getFailed().forEach(signatureResult -> {
        System.out.println("Error: " + signatureResult.getMessage());
    });
}

4. Onjuiste Certificaat‑stores Gebruiken

The Mistake: Niet de juiste certificaatautoriteiten configureren voor validatie.
The Fix: Zorg ervoor dat je Java‑keystore de root‑certificaten van je ondertekeningsautoriteit bevat. Dit is vooral belangrijk in enterprise‑omgevingen met interne CAs.

Beveiligings‑Best Practices

Verificatie is alleen zo veilig als je implementatie. Volg deze praktijken om kwetsbaarheden te vermijden:

1. Altijd Verifiëren Voor het Vertrouwen

Veronderstel nooit dat een document veilig is. Maak verificatie een verplichte stap vóór het verwerken van een ondertekend document:

Signature.verify() retourneert een boolean die de algehele geldigheid van de handtekeningen in het document aangeeft.

public boolean processDocument(String filePath) {
    Signature signature = new Signature(filePath);
    DigitalVerifyOptions options = new DigitalVerifyOptions();
    
    // Mandatory verification check
    if (!signature.verify(options).isValid()) {
        throw new SecurityException("Document failed signature verification");
    }
    
    // Only proceed if verification passed
    return processVerifiedDocument(filePath);
}

2. Houd Bibliotheken Up‑to‑date

Beveiligingskwetsbaarheden worden regelmatig gepatcht. Abonneer je op GroupDocs‑beveiligingsmededelingen en werk tijdig bij wanneer nieuwe versies verschijnen.

3. Gebruik Veilige Bestandsopslag

Bewaar geverifieerde documenten niet in publiek toegankelijke mappen. Gebruik passende toegangscontroles:

  • Beperk bestandsrechten tot alleen de benodigde gebruikers
  • Gebruik versleutelde opslag voor gevoelige documenten
  • Implementeer audit‑logging voor alle documenttoegang

4. Valideer Certificaatketens

VerificationOptions kan worden geconfigureerd om volledige ketenvalidatie af te dwingen tot een vertrouwde root‑autoriteit.

options.setVerifyCertificateChain(true);  // Ensures full chain validation

5. Stel Passende Time‑outs In

In productie, voeg time‑outs toe om DoS‑aanvallen te voorkomen:

VerificationOptions.setTimeout(30_000) stelt een limiet van 30 seconden in voor de verificatie‑operatie.

// Prevent hanging on corrupted or malicious files
signature.setTimeoutMilliseconds(5000);  // 5-second timeout

Wanneer GroupDocs te Gebruiken t.o.v. Ingebouwde Java‑oplossingen

Je vraagt je misschien af: “Java heeft ingebouwde handtekeningverificatie. Waarom GroupDocs gebruiken?”

Gebruik Java’s Ingebouwde API’s Wanneer:

  • Je alleen basis handtekeningverificatie nodig hebt
  • Je uitsluitend werkt met specifieke formaten (zoals JAR‑ondertekening)
  • Je geen externe afhankelijkheden wilt
  • Je cryptografische expertise in huis hebt

Gebruik GroupDocs.Signature Wanneer:

  • Je meerdere documentformaten moet verifiëren (PDF, DOCX, XLSX, enz.)
  • Je vereenvoudigde, high‑level API’s wilt
  • Je geavanceerde functies nodig hebt zoals datum‑gebaseerde verificatie
  • Je werkt met QR‑codes, barcodes of metadata‑handtekeningen
  • Ontwikkelsnelheid belangrijker is dan het aantal afhankelijkheden

Bottom line: GroupDocs.Signature is als een specialist in handtekeningverificatie in je team. Je zou het zelf kunnen bouwen met lagere‑niveau API’s, maar waarom weken spenderen als je het in dagen kunt implementeren?

Veelvoorkomende Problemen Oplossen

Kom je problemen tegen? Hier zijn oplossingen voor de meest voorkomende issues:

Probleem: “File not found” Exception

Symptoms: FileNotFoundException ondanks dat het bestand bestaat.

Solutions:

  1. Controleer het bestands‑padformaat (gebruik schuine strepen of escaped backslashes)
  2. Controleer bestandsrechten—kan je applicatie het bestand lezen?
  3. Gebruik absolute paden tijdens debugging om pad‑problemen te elimineren

Path.of() creëert een platform‑onafhankelijk padobject, waardoor padgerelateerde fouten verminderen.

// Debug file path issues
File file = new File(filePath);
System.out.println("File exists: " + file.exists());
System.out.println("Can read: " + file.canRead());
System.out.println("Absolute path: " + file.getAbsolutePath());

Probleem: Verificatie Mislukt bij Geldige Handtekeningen

Symptoms: Je weet dat de handtekening geldig is, maar verificatie geeft false.

Solutions:

  1. Controleer of het certificaat is verlopen (gebruik datum‑gebaseerde verificatie voor historische documenten)
  2. Zorg ervoor dat je Java‑keystore de root‑CA van het ondertekeningscertificaat bevat
  3. Verifieer dat het document niet is gewijzigd na ondertekening (zelfs kleine wijzigingen breken handtekeningen)
  4. Controleer of de handtekening algoritmen gebruikt die door jouw Java‑versie worden ondersteund

Probleem: Out of Memory‑fouten bij Grote Bestanden

Symptoms: OutOfMemoryError bij het verifiëren van grote PDF’s of documentbatches.

Solutions:

  1. Verhoog de JVM‑heap‑grootte: -Xmx2g (pas aan indien nodig)
  2. Verwerk bestanden individueel in plaats van alles tegelijk te laden
  3. Gebruik streaming‑verificatie voor zeer grote bestanden

Signature.verifyStream() verwerkt het document in delen om het geheugenverbruik laag te houden.

// Proper resource management
try (Signature signature = new Signature(filePath)) {
    VerificationResult result = signature.verify(options);
    // Process result
} // Automatically closes and releases resources

Probleem: Trage Verificatie‑prestaties

Symptoms: Verificatie duurt enkele seconden per document.

Solutions:

  1. Cache certificaat‑validatieresultaten bij het verifiëren van meerdere documenten van dezelfde ondertekenaar
  2. Gebruik parallelle verwerking voor batch‑verificatie
  3. Schakel onnodige verificatie‑opties uit
  4. Controleer netwerklatentie bij verificatie tegen externe certificaatstores

Geavanceerde Tips voor Productie‑omgevingen

Klaar om dit naar productie te brengen? Hier zijn enkele pro‑tips:

1. Implementeer Uitgebreide Logging

Log niet alleen succes of falen—log alles wat nuttig is voor debugging:

logger.info("Verification result: {}", result) registreert het volledige result‑object voor latere analyse.

import java.util.logging.Logger;

Logger logger = Logger.getLogger(YourClass.class.getName());

VerificationResult result = signature.verify(options);
logger.info(String.format(
    "Verification for %s: %s (Processed in %dms)",
    filePath,
    result.isValid() ? "PASSED" : "FAILED",
    result.getProcessingTime()
));

if (!result.isValid()) {
    result.getFailed().forEach(failure ->
        logger.warning("Verification failure: " + failure.getMessage())
    );
}

2. Gebruik Asynchrone Verificatie voor Betere Doorvoer

Bij het verwerken van meerdere documenten, gebruik async verwerking:

CompletableFuture.runAsync(() -> signature.verify(options)) voert verificatie uit in een aparte thread‑pool.

import java.util.concurrent.CompletableFuture;

public CompletableFuture<VerificationResult> verifyAsync(String filePath) {
    return CompletableFuture.supplyAsync(() -> {
        try (Signature signature = new Signature(filePath)) {
            return signature.verify(options);
        }
    });
}

3. Implementeer Circuit Breakers voor Externe Afhankelijkheden

Als verificatie afhankelijk is van externe certificaatvalidatiediensten, gebruik circuit breakers om uitval elegant af te handelen.

4. Cache Verificatieresultaten (Voorzichtig)

Voor documenten die niet veranderen, cache verificatieresultaten—maar implementeer een juiste cache‑invalidatie:

Cache.put(docId, result, Duration.ofHours(24)) slaat het resultaat een dag op.

// Pseudocode for caching strategy
String cacheKey = filePath + "_" + fileChecksum;
if (verificationCache.containsKey(cacheKey)) {
    return verificationCache.get(cacheKey);
}
// Verify and cache
VerificationResult result = signature.verify(options);
verificationCache.put(cacheKey, result, CACHE_TTL);

5. Monitor en Waarschuw bij Verificatiefouten

Volg de foutpercentages van verificaties. Een plotselinge piek kan duiden op:

  • Gecompromitteerde documenten in je systeem
  • Verlopen certificaten die vernieuwd moeten worden
  • Configuratieproblemen na implementatie

Praktische Toepassingen en Use Cases

Laten we bekijken hoe dit in echte scenario’s werkt:

Use Case 1: Contractbeheersysteem

Scenario: Een advocatenkantoor moet alle binnenkomende contracten verifiëren op correcte ondertekening.

Implementation: Signature signature = new Signature(contractFile); VerificationResult result = signature.verify(new VerificationOptions());

public boolean processIncomingContract(String contractPath) {
    try (Signature signature = new Signature(contractPath)) {
        DigitalVerifyOptions options = new DigitalVerifyOptions();
        options.setComments("Contract intake verification");
        
        VerificationResult result = signature.verify(options);
        
        if (result.isValid()) {
            // Move to approved contracts folder
            // Trigger workflow for legal review
            return true;
        } else {
            // Flag for manual review
            // Notify sender of invalid signature
            return false;
        }
    }
}

Use Case 2: Financiële Documentaudit

Scenario: Een bank moet historische leningsovereenkomsten verifiëren tijdens een regulatorische audit.

Implementation: Gebruik datum‑gebaseerde verificatie om te bevestigen dat handtekeningen geldig waren op het moment van ondertekening, zelfs als certificaten later zijn verlopen.

Use Case 3: Multi‑Party Documentvalidatie

Scenario: Een vastgoedtransactie vereist verificatie van handtekeningen van koper, verkoper en makelaar.

Implementation: Verifieer elke handtekening onafhankelijk en eis dat alle drie slagen voordat de overdracht wordt afgerond.

Prestatie‑overwegingen

Wanneer je duizenden documenten verwerkt, zijn prestaties cruciaal. Dit beïnvloedt de snelheid:

Factoren die Prestaties Beïnvloeden

  1. Documentgrootte
  2. Aantal handtekeningen
  3. Lengte van de certificaatketen
  4. Netwerktoegang

Optimalisatiestrategieën

  • Batchverwerking
  • Lokale certificaatcaching
  • Selectieve verificatie
  • Resource‑pooling

ExecutorService kan een pool van threads beheren om documenten gelijktijdig te verifiëren, waardoor de doorvoer verbetert.

// Example: Batch verification with parallel streams
List<String> filePaths = Arrays.asList("doc1.pdf", "doc2.pdf", "doc3.pdf");

Map<String, Boolean> results = filePaths.parallelStream()
    .collect(Collectors.toMap(
        path -> path,
        path -> {
            try (Signature sig = new Signature(path)) {
                return sig.verify(options).isValid();
            }
        }
    ));

Veelgestelde Vragen

Q: Wat is een digitale handtekening en hoe verschilt deze van een elektronische handtekening?
A: Een digitale handtekening gebruikt cryptografische algoritmen om authenticiteit te bewijzen en manipulatie te detecteren. Een elektronische handtekening is breder—elke elektronische indicatie van intentie om te ondertekenen (zoals het typen van je naam). Digitale handtekeningen zijn een specifiek, veiliger type elektronische handtekening.

Q: Hoe installeer ik GroupDocs.Signature voor Java?
A: Voeg het toe als een Maven‑ of Gradle‑afhankelijkheid (zie de installatie‑sectie hierboven), of download de JAR direct van de GroupDocs‑website en voeg deze toe aan de classpath van je project.

Q: Kan ik handtekeningen verifiëren zonder een GroupDocs‑licentie?
A: Ja, je kunt de gratis proefversie gebruiken voor ontwikkeling en testen. Deze heeft enkele beperkingen (zoals watermerken), maar is prima voor leren. Voor productie heb je een commerciële of tijdelijke licentie nodig.

Q: Wat gebeurt er als verificatie faalt?
A: De verify()‑methode retourneert een VerificationResult‑object met isValid() op false. Je kunt de details van het resultaat bekijken om te begrijpen waarom het is mislukt—verlopen certificaat, documentwijziging, ongeldig handtekeningalgoritme, enz.

Q: Hoe verbetert datumafhandeling de handtekeningverificatie?
A: Het stelt je in staat om te verifiëren of een handtekening op een specifiek moment geldig was, wat cruciaal is voor juridische en auditdoeleinden. Zonder datumafhandeling kun je alleen controleren of een handtekening nu geldig is—nutteloos voor historische documenten met verlopen certificaten.

Q: Kan ik meerdere handtekeningtypes in één document verifiëren?
A: Absoluut. PDF‑documenten kunnen meerdere digitale handtekeningen van verschillende ondertekenaars bevatten. Verifieer elke handtekening onafhankelijk met hetzelfde Signature‑object en verschillende verificatie‑opties indien nodig.

Q: Is GroupDocs.Signature thread‑safe?
A: Controleer de nieuwste documentatie voor garanties over thread‑safety, maar de veiligste aanpak is om per thread een aparte Signature‑instantie te maken voor batchverwerking.

Q: Welke documentformaten ondersteunt het?
A: PDF, Microsoft Office‑formaten (DOCX, XLSX, PPTX), afbeeldingen en vele anderen. Zie de documentatie voor de volledige lijst.

Aanvullende Resources

Laatst Bijgewerkt: 2026-07-01
Getest Met: GroupDocs.Signature 23.12 voor Java
Auteur: GroupDocs

Gerelateerde Tutorials